{"version":3,"sources":["../core/types/variable/VariableMetadata.ts","../core/types/variable/TypeGuards.ts","../core/types/variable/AdvancedTypeDetection.ts","../core/types/variable/LegacyCompatibility.ts","../core/types/variable.ts"],"names":["VariableMetadataUtils","createSource","syntax","hasInterpolation","isMultiLine","wrapperType","directive","mergeMetadata","base","additional","validateMetadata","metadata","isPipelineInput","pipelineStage","isImported","importPath","extractSourceInfo","source","parts","push","join","isComplexVariable","Boolean","isComplex","isImportedVariable","isPipelineInputVariable","createImportMetadata","additionalMetadata","importMetadata","createPipelineMetadata","pipelineMetadata","createComplexMetadata","complexMetadata","VariableSourceHelpers","createQuotedSource","createTemplateSource","createArraySource","createObjectSource","createCommandSource","createCodeSource","createPathSource","createReferenceSource","isSimpleText","variable","type","isInterpolatedText","isTemplate","isFileContent","isSectionContent","isObject","isArray","isComputed","isCommandResult","isPath","isExecutable","isPrimitive","isWhenExpression","isTextLike","isStructured","isExternal","VariableTypeGuards","hasType","getMatchingTypes","types","validateType","expectedType","isAnyType","includes","filterByType","variables","guard","filter","findByType","find","countByType","v","length","groupByType","groups","Map","existing","get","set","FastTypeGuards","isAnyTextType","isAnyDataType","isComplexType","requiresLazyEvaluation","AdvancedTypeDetection","getEffectiveType","originalType","isExecutableVariable","imported","detectComplexVariable","Array","value","resolveImportedVariable","resolveImportChain","maxDepth","current","depth","seen","Set","key","importSource","path","variableName","has","add","name","createdAt","modifiedAt","matchesTypePattern","pattern","effectiveType","RegExp","test","requiresSpecialEvaluation","getEvaluationPriority","resolved","hasLazyEvaluation","interpolationPoints","getVariableDependencies","dependencies","forEach","point","matches","expression","match","map","m","substring","varName","slice","trim","split","hasCircularDependency","allVariables","visited","i","depName","depVariable","delete","isSerializable","getComplexityScore","score","Math","round","LegacyVariableConverter","toLegacyVariable","mapToLegacyType","extractLegacyValue","fromLegacyVariable","legacy","defaultSource","newType","mapFromLegacyType","baseVariable","Date","now","String","command","resolvedPath","originalPath","isURL","isAbsolute","isModule","template","commandTemplate","codeTemplate","language","paramNames","legacyType","toLowerCase","hasLegacyType","migrateLegacyVariables","legacyVariables","convertToLegacyFormat","validateConversion","original","converted","reconverted","issues","originalValue","reconvertedValue","JSON","stringify","expectedLegacyType","valid","createMigrationReport","report","total","byType","complexVariables","warnings","refineTypeFromValue","legacyVariable","filePath","sectionName"],"mappings":"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","file":"chunk-V5L6FBQT.mjs","sourcesContent":["/**\n * Variable Metadata Management\n * \n * Types and utilities for managing variable metadata and source information.\n */\n\nimport { VariableSource, VariableMetadata } from './VariableTypes';\n\n// =========================================================================\n// METADATA UTILITY FUNCTIONS\n// =========================================================================\n\n/**\n * Utility class for managing variable metadata\n */\nexport class VariableMetadataUtils {\n  /**\n   * Create consistent variable source metadata\n   */\n  static createSource(\n    syntax: 'quoted' | 'template' | 'array' | 'object' | 'command' | 'code' | 'path' | 'reference',\n    hasInterpolation: boolean,\n    isMultiLine: boolean,\n    wrapperType?: 'singleQuote' | 'doubleQuote' | 'backtick' | 'brackets'\n  ): VariableSource {\n    return {\n      directive: 'var',\n      syntax,\n      wrapperType,\n      hasInterpolation,\n      isMultiLine\n    };\n  }\n\n  /**\n   * Merge metadata objects with proper precedence\n   * Additional metadata takes precedence over base metadata\n   */\n  static mergeMetadata(\n    base?: VariableMetadata,\n    additional?: VariableMetadata\n  ): VariableMetadata {\n    if (!base && !additional) {\n      return {};\n    }\n    if (!base) {\n      return additional || {};\n    }\n    if (!additional) {\n      return base;\n    }\n    \n    return {\n      ...base,\n      ...additional\n    };\n  }\n\n  /**\n   * Validate metadata consistency\n   */\n  static validateMetadata(metadata: VariableMetadata): boolean {\n    // Basic validation - can be extended\n    if (metadata.isPipelineInput && typeof metadata.pipelineStage !== 'undefined') {\n      return typeof metadata.pipelineStage === 'number' && metadata.pipelineStage >= 0;\n    }\n    \n    if (metadata.isImported && !metadata.importPath) {\n      return false;\n    }\n    \n    return true;\n  }\n\n  /**\n   * Extract source information for debugging\n   */\n  static extractSourceInfo(source: VariableSource): string {\n    const parts: string[] = [source.directive];\n    \n    if (source.syntax) {\n      parts.push(`syntax:${source.syntax}`);\n    }\n    \n    if (source.wrapperType) {\n      parts.push(`wrapper:${source.wrapperType}`);\n    }\n    \n    if (source.hasInterpolation) {\n      parts.push('interpolated');\n    }\n    \n    if (source.isMultiLine) {\n      parts.push('multiline');\n    }\n    \n    return parts.join(' ');\n  }\n\n  /**\n   * Check if metadata indicates a complex variable\n   */\n  static isComplexVariable(metadata?: VariableMetadata): boolean {\n    return Boolean(metadata?.isComplex);\n  }\n\n  /**\n   * Check if metadata indicates an imported variable\n   */\n  static isImportedVariable(metadata?: VariableMetadata): boolean {\n    return Boolean(metadata?.isImported);\n  }\n\n  /**\n   * Check if metadata indicates a pipeline input variable\n   */\n  static isPipelineInputVariable(metadata?: VariableMetadata): boolean {\n    return Boolean(metadata?.isPipelineInput);\n  }\n\n  /**\n   * Create metadata for imported variables\n   */\n  static createImportMetadata(\n    importPath: string,\n    additionalMetadata?: VariableMetadata\n  ): VariableMetadata {\n    const importMetadata: VariableMetadata = {\n      isImported: true,\n      importPath\n    };\n    \n    return this.mergeMetadata(importMetadata, additionalMetadata);\n  }\n\n  /**\n   * Create metadata for pipeline input variables\n   */\n  static createPipelineMetadata(\n    pipelineStage?: number,\n    additionalMetadata?: VariableMetadata\n  ): VariableMetadata {\n    const pipelineMetadata: VariableMetadata = {\n      isPipelineInput: true,\n      pipelineStage\n    };\n    \n    return this.mergeMetadata(pipelineMetadata, additionalMetadata);\n  }\n\n  /**\n   * Create metadata for complex variables\n   */\n  static createComplexMetadata(\n    additionalMetadata?: VariableMetadata\n  ): VariableMetadata {\n    const complexMetadata: VariableMetadata = {\n      isComplex: true\n    };\n    \n    return this.mergeMetadata(complexMetadata, additionalMetadata);\n  }\n}\n\n// =========================================================================\n// SOURCE CREATION HELPERS\n// =========================================================================\n\n/**\n * Helper functions for creating common variable source configurations\n */\nexport class VariableSourceHelpers {\n  /**\n   * Create source for quoted text variables\n   */\n  static createQuotedSource(\n    wrapperType: 'singleQuote' | 'doubleQuote',\n    hasInterpolation: boolean = false,\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'quoted',\n      hasInterpolation,\n      isMultiLine,\n      wrapperType\n    );\n  }\n\n  /**\n   * Create source for template variables\n   */\n  static createTemplateSource(\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'template',\n      true, // Templates always have interpolation\n      isMultiLine,\n      'backtick'\n    );\n  }\n\n  /**\n   * Create source for array variables\n   */\n  static createArraySource(\n    hasInterpolation: boolean = false,\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'array',\n      hasInterpolation,\n      isMultiLine,\n      'brackets'\n    );\n  }\n\n  /**\n   * Create source for object variables\n   */\n  static createObjectSource(\n    hasInterpolation: boolean = false,\n    isMultiLine: boolean = true // Objects are typically multiline\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'object',\n      hasInterpolation,\n      isMultiLine\n    );\n  }\n\n  /**\n   * Create source for command variables\n   */\n  static createCommandSource(\n    isMultiLine: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'command',\n      true, // Commands typically have interpolation\n      isMultiLine\n    );\n  }\n\n  /**\n   * Create source for code variables\n   */\n  static createCodeSource(\n    isMultiLine: boolean = true // Code is typically multiline\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'code',\n      true, // Code may have interpolation\n      isMultiLine\n    );\n  }\n\n  /**\n   * Create source for path variables\n   */\n  static createPathSource(\n    hasInterpolation: boolean = false\n  ): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'path',\n      hasInterpolation,\n      false, // Paths are typically single line\n      'brackets'\n    );\n  }\n\n  /**\n   * Create source for reference variables\n   */\n  static createReferenceSource(): VariableSource {\n    return VariableMetadataUtils.createSource(\n      'reference',\n      false, // References don't have interpolation\n      false\n    );\n  }\n}","/**\n * Variable Type Guards\n * \n * Runtime type checking and TypeScript type narrowing functions for all variable types.\n */\n\nimport {\n  Variable,\n  VariableTypeDiscriminator,\n  SimpleTextVariable,\n  InterpolatedTextVariable,\n  TemplateVariable,\n  FileContentVariable,\n  SectionContentVariable,\n  ObjectVariable,\n  ArrayVariable,\n  ComputedVariable,\n  CommandResultVariable,\n  PathVariable,\n  ImportedVariable,\n  ExecutableVariable,\n  PipelineInputVariable,\n  PrimitiveVariable,\n  WhenExpressionVariable,\n  TextLikeVariable,\n  StructuredVariable,\n  ExternalVariable\n} from './VariableTypes';\n\n// =========================================================================\n// INDIVIDUAL TYPE GUARDS\n// =========================================================================\n\n/**\n * Type guard for SimpleTextVariable\n */\nexport function isSimpleText(variable: Variable): variable is SimpleTextVariable {\n  return variable.type === 'simple-text';\n}\n\n/**\n * Type guard for InterpolatedTextVariable\n */\nexport function isInterpolatedText(variable: Variable): variable is InterpolatedTextVariable {\n  return variable.type === 'interpolated-text';\n}\n\n/**\n * Type guard for TemplateVariable\n */\nexport function isTemplate(variable: Variable): variable is TemplateVariable {\n  return variable.type === 'template';\n}\n\n/**\n * Type guard for FileContentVariable\n */\nexport function isFileContent(variable: Variable): variable is FileContentVariable {\n  return variable.type === 'file-content';\n}\n\n/**\n * Type guard for SectionContentVariable\n */\nexport function isSectionContent(variable: Variable): variable is SectionContentVariable {\n  return variable.type === 'section-content';\n}\n\n/**\n * Type guard for ObjectVariable\n */\nexport function isObject(variable: Variable): variable is ObjectVariable {\n  return variable.type === 'object';\n}\n\n/**\n * Type guard for ArrayVariable\n */\nexport function isArray(variable: Variable): variable is ArrayVariable {\n  return variable.type === 'array';\n}\n\n/**\n * Type guard for ComputedVariable\n */\nexport function isComputed(variable: Variable): variable is ComputedVariable {\n  return variable.type === 'computed';\n}\n\n/**\n * Type guard for CommandResultVariable\n */\nexport function isCommandResult(variable: Variable): variable is CommandResultVariable {\n  return variable.type === 'command-result';\n}\n\n/**\n * Type guard for PathVariable\n */\nexport function isPath(variable: Variable): variable is PathVariable {\n  return variable.type === 'path';\n}\n\n/**\n * Type guard for ImportedVariable\n */\nexport function isImported(variable: Variable): variable is ImportedVariable {\n  return variable.type === 'imported';\n}\n\n/**\n * Type guard for ExecutableVariable\n */\nexport function isExecutable(variable: Variable): variable is ExecutableVariable {\n  return variable.type === 'executable';\n}\n\n/**\n * Type guard for PipelineInputVariable\n */\nexport function isPipelineInput(variable: Variable): variable is PipelineInputVariable {\n  return variable.type === 'pipeline-input';\n}\n\n/**\n * Type guard for PrimitiveVariable\n */\nexport function isPrimitive(variable: Variable): variable is PrimitiveVariable {\n  return variable.type === 'primitive';\n}\n\n/**\n * Type guard for WhenExpressionVariable\n */\nexport function isWhenExpression(variable: Variable): variable is WhenExpressionVariable {\n  return variable.type === 'when-expression';\n}\n\n// =========================================================================\n// COMPOSITE TYPE GUARDS\n// =========================================================================\n\n/**\n * Check if variable contains text-like content\n */\nexport function isTextLike(variable: Variable): variable is TextLikeVariable {\n  return isSimpleText(variable) || \n         isInterpolatedText(variable) || \n         isTemplate(variable) || \n         isFileContent(variable) || \n         isSectionContent(variable) ||\n         isCommandResult(variable);\n}\n\n/**\n * Check if variable contains structured data\n */\nexport function isStructured(variable: Variable): variable is StructuredVariable {\n  return isObject(variable) || isArray(variable);\n}\n\n/**\n * Check if variable was created from external content\n */\nexport function isExternal(variable: Variable): variable is ExternalVariable {\n  return isFileContent(variable) || \n         isSectionContent(variable) || \n         isImported(variable) || \n         isCommandResult(variable) ||\n         isComputed(variable);\n}\n\n// =========================================================================\n// UTILITY TYPE GUARDS\n// =========================================================================\n\n/**\n * Type guard class for organized access to all type checking functions\n */\nexport class VariableTypeGuards {\n  // Individual type guards\n  static isSimpleText = isSimpleText;\n  static isInterpolatedText = isInterpolatedText;\n  static isTemplate = isTemplate;\n  static isFileContent = isFileContent;\n  static isSectionContent = isSectionContent;\n  static isObject = isObject;\n  static isArray = isArray;\n  static isComputed = isComputed;\n  static isCommandResult = isCommandResult;\n  static isPath = isPath;\n  static isImported = isImported;\n  static isExecutable = isExecutable;\n  static isPipelineInput = isPipelineInput;\n  static isPrimitive = isPrimitive;\n  static isWhenExpression = isWhenExpression;\n\n  // Composite type guards\n  static isTextLike = isTextLike;\n  static isStructured = isStructured;\n  static isExternal = isExternal;\n\n  /**\n   * Check if variable has a specific type discriminator\n   */\n  static hasType(variable: Variable, type: VariableTypeDiscriminator): boolean {\n    return variable.type === type;\n  }\n\n  /**\n   * Get all type discriminators that match the variable\n   */\n  static getMatchingTypes(variable: Variable): VariableTypeDiscriminator[] {\n    const types: VariableTypeDiscriminator[] = [variable.type];\n    \n    // Add composite type categories\n    if (this.isTextLike(variable)) {\n      types.push('simple-text'); // Representing text-like category\n    }\n    \n    if (this.isStructured(variable)) {\n      types.push('object'); // Representing structured category\n    }\n    \n    if (this.isExternal(variable)) {\n      types.push('imported'); // Representing external category\n    }\n    \n    return types;\n  }\n\n  /**\n   * Validate that a variable matches expected type\n   */\n  static validateType(\n    variable: Variable, \n    expectedType: VariableTypeDiscriminator\n  ): boolean {\n    return variable.type === expectedType;\n  }\n\n  /**\n   * Check if variable is of any of the specified types\n   */\n  static isAnyType(\n    variable: Variable, \n    types: VariableTypeDiscriminator[]\n  ): boolean {\n    return types.includes(variable.type);\n  }\n\n  /**\n   * Filter variables by type\n   */\n  static filterByType<T extends Variable>(\n    variables: Variable[],\n    guard: (variable: Variable) => variable is T\n  ): T[] {\n    return variables.filter(guard);\n  }\n\n  /**\n   * Find first variable of specified type\n   */\n  static findByType<T extends Variable>(\n    variables: Variable[],\n    guard: (variable: Variable) => variable is T\n  ): T | undefined {\n    return variables.find(guard);\n  }\n\n  /**\n   * Count variables by type\n   */\n  static countByType(\n    variables: Variable[],\n    type: VariableTypeDiscriminator\n  ): number {\n    return variables.filter(v => v.type === type).length;\n  }\n\n  /**\n   * Group variables by their types\n   */\n  static groupByType(variables: Variable[]): Map<VariableTypeDiscriminator, Variable[]> {\n    const groups = new Map<VariableTypeDiscriminator, Variable[]>();\n    \n    for (const variable of variables) {\n      const existing = groups.get(variable.type) || [];\n      existing.push(variable);\n      groups.set(variable.type, existing);\n    }\n    \n    return groups;\n  }\n}\n\n// =========================================================================\n// PERFORMANCE OPTIMIZED TYPE CHECKING\n// =========================================================================\n\n/**\n * Fast type checking utilities for performance-critical paths\n */\nexport class FastTypeGuards {\n  /**\n   * Fast check for text types (most common)\n   */\n  static isAnyTextType(variable: Variable): boolean {\n    const type = variable.type;\n    return type === 'simple-text' || \n           type === 'interpolated-text' || \n           type === 'template' ||\n           type === 'file-content' ||\n           type === 'section-content' ||\n           type === 'command-result';\n  }\n\n  /**\n   * Fast check for data types\n   */\n  static isAnyDataType(variable: Variable): boolean {\n    const type = variable.type;\n    return type === 'object' || \n           type === 'array' || \n           type === 'computed' || \n           type === 'primitive';\n  }\n\n  /**\n   * Fast check for complex types that might need special handling\n   */\n  static isComplexType(variable: Variable): boolean {\n    const type = variable.type;\n    return type === 'imported' || \n           type === 'executable' || \n           type === 'pipeline-input' ||\n           type === 'path';\n  }\n\n  /**\n   * Check if variable type requires lazy evaluation\n   */\n  static requiresLazyEvaluation(variable: Variable): boolean {\n    return isTemplate(variable) || \n           isPipelineInput(variable) ||\n           isWhenExpression(variable) ||\n           (isImported(variable) && variable.metadata?.isComplex);\n  }\n}","/**\n * Advanced Type Detection\n * \n * Specialized type detection logic for complex scenarios including imported variables,\n * executable detection, and effective type resolution.\n */\n\nimport {\n  Variable,\n  VariableTypeDiscriminator,\n  ImportedVariable\n} from './VariableTypes';\nimport { isImported, isExecutable } from './TypeGuards';\n\n// =========================================================================\n// ADVANCED TYPE DETECTION CLASS\n// =========================================================================\n\n/**\n * Advanced type detection utilities for complex variable scenarios\n */\nexport class AdvancedTypeDetection {\n  \n  /**\n   * Get the effective type of a variable, considering imported variables\n   * This resolves the \"real\" type by looking through import wrappers\n   */\n  static getEffectiveType(variable: Variable): VariableTypeDiscriminator {\n    if (isImported(variable)) {\n      return (variable as ImportedVariable).originalType;\n    }\n    return variable.type;\n  }\n\n  /**\n   * Check if variable is an executable, including imported executables\n   * This handles the complex case where an executable might be imported\n   */\n  static isExecutableVariable(variable: Variable): boolean {\n    if (isExecutable(variable)) return true;\n    if (isImported(variable)) {\n      const imported = variable as ImportedVariable;\n      return imported.originalType === 'executable' || \n             imported.metadata?.originalType === 'executable';\n    }\n    return false;\n  }\n\n  /**\n   * Detect if variable contains nested directive complexity\n   * This is used to determine if a variable needs special handling\n   */\n  static detectComplexVariable(variable: Variable): boolean {\n    // Check metadata first\n    if (variable.metadata?.isComplex) {\n      return true;\n    }\n\n    // Type-specific complexity detection\n    switch (variable.type) {\n      case 'object':\n      case 'array':\n        return (variable as any).isComplex || false;\n      \n      case 'template':\n        return Array.isArray(variable.value); // Lazy-evaluated templates are complex\n      \n      case 'imported':\n        return this.detectComplexVariable(this.resolveImportedVariable(variable));\n      \n      case 'pipeline-input':\n        return true; // Pipeline inputs are inherently complex\n      \n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Follow import chains to resolve the original variable\n   * This handles nested imports and circular references\n   */\n  static resolveImportChain(variable: Variable, maxDepth: number = 10): Variable {\n    let current = variable;\n    let depth = 0;\n    const seen = new Set<string>();\n\n    while (isImported(current) && depth < maxDepth) {\n      const imported = current as ImportedVariable;\n      const key = `${imported.importSource.path}:${imported.importSource.variableName}`;\n      \n      // Prevent circular references\n      if (seen.has(key)) {\n        break;\n      }\n      seen.add(key);\n\n      // In a real implementation, this would resolve the import\n      // For now, we'll break the chain\n      break;\n    }\n\n    return current;\n  }\n\n  /**\n   * Resolve an imported variable to its underlying type\n   */\n  static resolveImportedVariable(variable: Variable): Variable {\n    if (!isImported(variable)) {\n      return variable;\n    }\n\n    const imported = variable as ImportedVariable;\n    \n    // Create a synthetic variable representing the imported content\n    return {\n      type: imported.originalType,\n      name: imported.name,\n      value: imported.value,\n      source: imported.source,\n      createdAt: imported.createdAt,\n      modifiedAt: imported.modifiedAt,\n      metadata: imported.metadata\n    } as Variable;\n  }\n\n  /**\n   * Detect if variable type matches a pattern\n   */\n  static matchesTypePattern(\n    variable: Variable, \n    pattern: VariableTypeDiscriminator | VariableTypeDiscriminator[] | RegExp\n  ): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n\n    if (pattern instanceof RegExp) {\n      return pattern.test(effectiveType);\n    }\n\n    if (Array.isArray(pattern)) {\n      return pattern.includes(effectiveType);\n    }\n\n    return effectiveType === pattern;\n  }\n\n  /**\n   * Check if variable requires special evaluation handling\n   */\n  static requiresSpecialEvaluation(variable: Variable): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    return (\n      effectiveType === 'template' ||\n      effectiveType === 'executable' ||\n      effectiveType === 'pipeline-input' ||\n      effectiveType === 'computed' ||\n      this.detectComplexVariable(variable)\n    );\n  }\n\n  /**\n   * Determine evaluation priority for variable resolution\n   * Lower numbers = higher priority\n   */\n  static getEvaluationPriority(variable: Variable): number {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    switch (effectiveType) {\n      case 'primitive':\n      case 'simple-text':\n        return 1; // Highest priority - simple values\n\n      case 'interpolated-text':\n      case 'file-content':\n      case 'section-content':\n        return 2; // Medium-high priority - needs resolution but straightforward\n\n      case 'object':\n      case 'array':\n        return variable.isComplex ? 4 : 3; // Priority based on complexity\n\n      case 'command-result':\n      case 'computed':\n        return 5; // Lower priority - requires execution\n\n      case 'template':\n      case 'executable':\n        return 6; // Low priority - complex evaluation\n\n      case 'pipeline-input':\n        return 7; // Lowest priority - pipeline dependency\n\n      case 'imported':\n        // Recursively determine priority of imported content\n        const resolved = this.resolveImportedVariable(variable);\n        return this.getEvaluationPriority(resolved) + 1; // Slightly lower than original\n\n      default:\n        return 5; // Default medium priority\n    }\n  }\n\n  /**\n   * Check if variable has lazy evaluation semantics\n   */\n  static hasLazyEvaluation(variable: Variable): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    return (\n      effectiveType === 'template' ||\n      effectiveType === 'pipeline-input' ||\n      (effectiveType === 'executable' && variable.type !== 'imported') ||\n      this.detectComplexVariable(variable)\n    );\n  }\n\n  /**\n   * Detect if variable contains interpolation points\n   */\n  static hasInterpolation(variable: Variable): boolean {\n    switch (variable.type) {\n      case 'interpolated-text':\n        return variable.interpolationPoints.length > 0;\n      \n      case 'template':\n        return true; // Templates always have interpolation\n      \n      case 'imported':\n        return this.hasInterpolation(this.resolveImportedVariable(variable));\n      \n      default:\n        return variable.source.hasInterpolation;\n    }\n  }\n\n  /**\n   * Get variable dependencies for evaluation ordering\n   */\n  static getVariableDependencies(variable: Variable): string[] {\n    const dependencies: string[] = [];\n\n    switch (variable.type) {\n      case 'interpolated-text':\n        // Extract variable names from interpolation points\n        variable.interpolationPoints.forEach(point => {\n          const matches = point.expression.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/g);\n          if (matches) {\n            dependencies.push(...matches.map(m => m.substring(1)));\n          }\n        });\n        break;\n\n      case 'template':\n        if (typeof variable.value === 'string') {\n          // Extract dependencies from template string\n          const matches = variable.value.match(/\\{\\{([^}]+)\\}\\}/g);\n          if (matches) {\n            matches.forEach(match => {\n              const varName = match.slice(2, -2).trim().split('.')[0];\n              if (varName && !dependencies.includes(varName)) {\n                dependencies.push(varName);\n              }\n            });\n          }\n        }\n        break;\n\n      case 'imported':\n        // Dependencies are resolved at import time\n        break;\n\n      default:\n        // For other types, check source interpolation flag\n        if (variable.source.hasInterpolation && typeof variable.value === 'string') {\n          const matches = variable.value.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/g);\n          if (matches) {\n            dependencies.push(...matches.map(m => m.substring(1)));\n          }\n        }\n    }\n\n    return [...new Set(dependencies)]; // Remove duplicates\n  }\n\n  /**\n   * Check if variable creates a circular dependency\n   */\n  static hasCircularDependency(\n    variable: Variable,\n    allVariables: Map<string, Variable>,\n    visited: Set<string> = new Set()\n  ): boolean {\n    if (visited.has(variable.name)) {\n      return true; // Circular dependency detected\n    }\n\n    visited.add(variable.name);\n    const dependencies = this.getVariableDependencies(variable);\n\n    for (let i = 0; i < dependencies.length; i++) {\n      const depName = dependencies[i];\n      const depVariable = allVariables.get(depName);\n      if (depVariable && this.hasCircularDependency(depVariable, allVariables, visited)) {\n        return true;\n      }\n    }\n\n    visited.delete(variable.name);\n    return false;\n  }\n\n  /**\n   * Determine if variable can be safely serialized\n   */\n  static isSerializable(variable: Variable): boolean {\n    const effectiveType = this.getEffectiveType(variable);\n    \n    switch (effectiveType) {\n      case 'simple-text':\n      case 'interpolated-text':\n      case 'file-content':\n      case 'section-content':\n      case 'command-result':\n      case 'primitive':\n        return true;\n\n      case 'object':\n      case 'array':\n        return !this.detectComplexVariable(variable);\n\n      case 'path':\n        return true; // Path metadata is serializable\n\n      case 'template':\n      case 'executable':\n      case 'pipeline-input':\n      case 'computed':\n        return false; // These require execution context\n\n      case 'imported':\n        return this.isSerializable(this.resolveImportedVariable(variable));\n\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Get variable complexity score for performance optimization\n   */\n  static getComplexityScore(variable: Variable): number {\n    let score = 0;\n    const effectiveType = this.getEffectiveType(variable);\n\n    // Base complexity by type\n    switch (effectiveType) {\n      case 'primitive':\n      case 'simple-text':\n        score += 1;\n        break;\n      case 'interpolated-text':\n        score += 2 + (variable as any).interpolationPoints?.length || 0;\n        break;\n      case 'template':\n        score += 3;\n        if (Array.isArray(variable.value)) score += 2; // Lazy evaluation\n        break;\n      case 'object':\n      case 'array':\n        score += 2;\n        if (variable.isComplex) score += 3;\n        break;\n      case 'executable':\n      case 'computed':\n        score += 5;\n        break;\n      case 'pipeline-input':\n        score += 4;\n        break;\n      default:\n        score += 2;\n    }\n\n    // Additional complexity factors\n    if (this.hasInterpolation(variable)) score += 1;\n    if (this.detectComplexVariable(variable)) score += 2;\n    if (variable.metadata?.isImported) score += 1;\n    \n    const dependencies = this.getVariableDependencies(variable);\n    score += dependencies.length * 0.5;\n\n    return Math.round(score);\n  }\n}","/**\n * Legacy Compatibility System\n * \n * Conversion between old and new variable systems during the transition period.\n * This module handles bidirectional conversion while preserving semantics.\n */\n\nimport {\n  Variable,\n  VariableTypeDiscriminator,\n  VariableSource,\n  VariableMetadata\n} from './VariableTypes';\n\n// =========================================================================\n// LEGACY TYPES (for compatibility)\n// =========================================================================\n\n/**\n * Legacy variable type structure\n */\ninterface LegacyVariable {\n  type: string;\n  name: string;\n  value: any;\n  metadata?: any;\n}\n\n// =========================================================================\n// LEGACY CONVERSION CLASS\n// =========================================================================\n\n/**\n * Handles conversion between new and legacy variable systems\n */\nexport class LegacyVariableConverter {\n\n  /**\n   * Convert a new variable to legacy format\n   * This ensures backward compatibility during transition\n   */\n  static toLegacyVariable(variable: Variable): LegacyVariable {\n    return {\n      type: this.mapToLegacyType(variable.type),\n      name: variable.name,\n      value: this.extractLegacyValue(variable),\n      metadata: variable.metadata\n    };\n  }\n\n  /**\n   * Convert a legacy variable to new format\n   * This allows importing old variable definitions\n   */\n  static fromLegacyVariable(\n    legacy: LegacyVariable,\n    source?: VariableSource\n  ): Variable {\n    const defaultSource: VariableSource = source || {\n      directive: 'var',\n      syntax: 'reference',\n      hasInterpolation: false,\n      isMultiLine: false\n    };\n\n    const newType = this.mapFromLegacyType(legacy.type);\n    const baseVariable = {\n      name: legacy.name,\n      createdAt: Date.now(),\n      modifiedAt: Date.now(),\n      source: defaultSource,\n      metadata: legacy.metadata\n    };\n\n    // Create appropriate variable type based on legacy type\n    switch (newType) {\n      case 'simple-text':\n        return {\n          type: 'simple-text',\n          value: String(legacy.value),\n          ...baseVariable\n        };\n\n      case 'object':\n        return {\n          type: 'object',\n          value: legacy.value || {},\n          isComplex: false,\n          ...baseVariable\n        };\n\n      case 'array':\n        return {\n          type: 'array',\n          value: Array.isArray(legacy.value) ? legacy.value : [],\n          isComplex: false,\n          ...baseVariable\n        };\n\n      case 'command-result':\n        return {\n          type: 'command-result',\n          value: String(legacy.value),\n          command: legacy.metadata?.command || '',\n          ...baseVariable\n        };\n\n      case 'path':\n        return {\n          type: 'path',\n          value: {\n            resolvedPath: legacy.value?.resolvedPath || String(legacy.value),\n            originalPath: legacy.value?.originalPath || String(legacy.value),\n            isURL: legacy.value?.isURL || false,\n            isAbsolute: legacy.value?.isAbsolute || false\n          },\n          ...baseVariable\n        };\n\n      case 'imported':\n        return {\n          type: 'imported',\n          value: legacy.value,\n          originalType: legacy.metadata?.originalType || 'simple-text',\n          importSource: {\n            path: legacy.metadata?.importPath || '',\n            isModule: legacy.metadata?.isModule || false,\n            variableName: legacy.name\n          },\n          ...baseVariable\n        };\n\n      case 'executable':\n        return {\n          type: 'executable',\n          value: {\n            type: legacy.value?.type || 'command',\n            template: legacy.value?.commandTemplate || legacy.value?.codeTemplate || '',\n            language: legacy.value?.language\n          },\n          paramNames: legacy.value?.paramNames || [],\n          ...baseVariable\n        };\n\n      default:\n        // Fallback to simple text\n        return {\n          type: 'simple-text',\n          value: String(legacy.value),\n          ...baseVariable\n        };\n    }\n  }\n\n  /**\n   * Map new variable types to legacy types\n   * This preserves the old type hierarchy during transition\n   */\n  private static mapToLegacyType(type: VariableTypeDiscriminator): string {\n    switch (type) {\n      case 'simple-text':\n      case 'interpolated-text':\n      case 'template':\n      case 'file-content':\n      case 'section-content':\n        return 'text';\n      \n      case 'object':\n      case 'array':\n      case 'computed':\n      case 'pipeline-input':\n      case 'primitive':\n        return 'data';\n      \n      case 'path':\n        return 'path';\n      \n      case 'command-result':\n        return 'command';\n      \n      case 'imported':\n        return 'import';\n      \n      case 'executable':\n        return 'executable';\n      \n      default:\n        return 'data'; // Fallback\n    }\n  }\n\n  /**\n   * Map legacy types to new variable types\n   */\n  private static mapFromLegacyType(legacyType: string): VariableTypeDiscriminator {\n    switch (legacyType.toLowerCase()) {\n      case 'text':\n        return 'simple-text';\n      case 'data':\n        return 'object'; // Default data type\n      case 'path':\n        return 'path';\n      case 'command':\n        return 'command-result';\n      case 'import':\n        return 'imported';\n      case 'executable':\n        return 'executable';\n      default:\n        return 'simple-text'; // Fallback\n    }\n  }\n\n  /**\n   * Extract value in legacy format\n   * This ensures the value structure matches legacy expectations\n   */\n  private static extractLegacyValue(variable: Variable): any {\n    switch (variable.type) {\n      case 'simple-text':\n      case 'interpolated-text':\n      case 'template':\n      case 'file-content':\n      case 'section-content':\n      case 'command-result':\n        return variable.value;\n      \n      case 'object':\n      case 'array':\n      case 'computed':\n      case 'primitive':\n        return variable.value;\n      \n      case 'path':\n        return variable.value;\n      \n      case 'imported':\n        return variable.value;\n      \n      case 'executable':\n        return {\n          type: variable.value.type,\n          paramNames: variable.paramNames,\n          ...(variable.value.type === 'command' \n            ? { commandTemplate: variable.value.template }\n            : { codeTemplate: variable.value.template, language: variable.value.language })\n        };\n      \n      case 'pipeline-input':\n        return variable.value;\n      \n      default:\n        return variable.value;\n    }\n  }\n\n  /**\n   * Check if a variable has legacy type information\n   */\n  static hasLegacyType(variable: any): boolean {\n    return 'type' in variable && \n           typeof variable.type === 'string' && \n           ['text', 'data', 'path', 'command', 'import', 'executable'].includes(variable.type);\n  }\n\n  /**\n   * Migrate a collection of legacy variables\n   */\n  static migrateLegacyVariables(\n    legacyVariables: LegacyVariable[],\n    defaultSource?: VariableSource\n  ): Variable[] {\n    return legacyVariables.map(legacy => \n      this.fromLegacyVariable(legacy, defaultSource)\n    );\n  }\n\n  /**\n   * Convert a collection of new variables to legacy format\n   */\n  static convertToLegacyFormat(variables: Variable[]): LegacyVariable[] {\n    return variables.map(variable => this.toLegacyVariable(variable));\n  }\n\n  /**\n   * Validate that conversion is lossless\n   */\n  static validateConversion(\n    original: Variable, \n    converted: LegacyVariable, \n    reconverted: Variable\n  ): { valid: boolean; issues: string[] } {\n    const issues: string[] = [];\n\n    // Check name preservation\n    if (original.name !== reconverted.name) {\n      issues.push(`Name mismatch: ${original.name} -> ${reconverted.name}`);\n    }\n\n    // Check value preservation (basic check)\n    const originalValue = this.extractLegacyValue(original);\n    const reconvertedValue = this.extractLegacyValue(reconverted);\n    \n    if (JSON.stringify(originalValue) !== JSON.stringify(reconvertedValue)) {\n      issues.push('Value structure changed during conversion');\n    }\n\n    // Check type mapping\n    const expectedLegacyType = this.mapToLegacyType(original.type);\n    if (converted.type !== expectedLegacyType) {\n      issues.push(`Type mapping error: ${original.type} -> ${converted.type} (expected ${expectedLegacyType})`);\n    }\n\n    return {\n      valid: issues.length === 0,\n      issues\n    };\n  }\n\n  /**\n   * Create a migration report for a set of variables\n   */\n  static createMigrationReport(\n    legacyVariables: LegacyVariable[]\n  ): {\n    total: number;\n    byType: Record<string, number>;\n    complexVariables: string[];\n    warnings: string[];\n  } {\n    const report = {\n      total: legacyVariables.length,\n      byType: {} as Record<string, number>,\n      complexVariables: [] as string[],\n      warnings: [] as string[]\n    };\n\n    legacyVariables.forEach(variable => {\n      // Count by type\n      report.byType[variable.type] = (report.byType[variable.type] || 0) + 1;\n\n      // Check for complex cases\n      if (variable.metadata?.isComplex) {\n        report.complexVariables.push(variable.name);\n      }\n\n      // Check for potential issues\n      if (!this.mapFromLegacyType(variable.type)) {\n        report.warnings.push(`Unknown legacy type: ${variable.type} for variable ${variable.name}`);\n      }\n\n      if (variable.value && typeof variable.value === 'object' && 'originalType' in variable.value) {\n        report.warnings.push(`Variable ${variable.name} may have nested type information`);\n      }\n    });\n\n    return report;\n  }\n\n  /**\n   * Attempt automatic type refinement during conversion\n   */\n  static refineTypeFromValue(\n    legacyVariable: LegacyVariable\n  ): VariableTypeDiscriminator {\n    const value = legacyVariable.value;\n    \n    // If legacy type is 'data', try to be more specific\n    if (legacyVariable.type === 'data') {\n      if (typeof value === 'number' || typeof value === 'boolean' || value === null) {\n        return 'primitive';\n      } else if (Array.isArray(value)) {\n        return 'array';\n      } else if (typeof value === 'object' && value !== null) {\n        return 'object';\n      }\n    }\n\n    // If legacy type is 'text', check for special cases\n    if (legacyVariable.type === 'text') {\n      if (typeof value === 'string') {\n        if (value.includes('{{') && value.includes('}}')) {\n          return 'template';\n        } else if (legacyVariable.metadata?.hasInterpolation) {\n          return 'interpolated-text';\n        } else if (legacyVariable.metadata?.filePath) {\n          return legacyVariable.metadata.sectionName ? 'section-content' : 'file-content';\n        }\n      }\n    }\n\n    // Fall back to standard mapping\n    return this.mapFromLegacyType(legacyVariable.type);\n  }\n}","/**\n * Variable System Module\n * \n * Unified export of the refactored variable system components.\n * This module provides the complete variable system API while maintaining\n * backward compatibility with the previous monolithic structure.\n */\n\n// =========================================================================\n// TYPE DEFINITIONS\n// =========================================================================\n\nexport * from './variable/VariableTypes';\n\n// =========================================================================\n// METADATA SYSTEM\n// =========================================================================\n\nexport * from './variable/VariableMetadata';\n\n// =========================================================================\n// TYPE GUARDS\n// =========================================================================\n\nexport * from './variable/TypeGuards';\n\n// =========================================================================\n// FACTORY FUNCTIONS\n// =========================================================================\n\nexport * from './variable/VariableFactories';\n\n// =========================================================================\n// ADVANCED TYPE DETECTION\n// =========================================================================\n\nexport * from './variable/AdvancedTypeDetection';\n\n// =========================================================================\n// LEGACY COMPATIBILITY\n// =========================================================================\n\nexport * from './variable/LegacyCompatibility';\n\n// =========================================================================\n// CONVENIENT RE-EXPORTS\n// =========================================================================\n\n// Re-export the main Variable type for easy access\nexport type { Variable } from './variable/VariableTypes';\n\n// Re-export the discriminator type\nexport type { VariableTypeDiscriminator } from './variable/VariableTypes';\n\n// Re-export commonly used factory methods\nexport { VariableFactory } from './variable/VariableFactories';\n\n// Re-export commonly used type guards\nexport { VariableTypeGuards } from './variable/TypeGuards';\n\n// Re-export advanced detection\nexport { AdvancedTypeDetection } from './variable/AdvancedTypeDetection';\n\n// Re-export legacy converter\nexport { LegacyVariableConverter } from './variable/LegacyCompatibility';\n\n// Re-export metadata utilities\nexport { VariableMetadataUtils, VariableSourceHelpers } from './variable/VariableMetadata';\n\n// =========================================================================\n// BACKWARD COMPATIBILITY FUNCTIONS\n// =========================================================================\n\nimport { Variable } from './variable/VariableTypes';\nimport { LegacyVariableConverter } from './variable/LegacyCompatibility';\nimport { AdvancedTypeDetection } from './variable/AdvancedTypeDetection';\n\n/**\n * Convert a new variable to legacy format (backward compatibility)\n */\nexport function toLegacyVariable(variable: Variable): any {\n  return LegacyVariableConverter.toLegacyVariable(variable);\n}\n\n/**\n * Check for legacy variable types in imported variables (backward compatibility)\n */\nexport function hasLegacyType(variable: Variable): boolean {\n  return LegacyVariableConverter.hasLegacyType(variable);\n}\n\n/**\n * Check if variable is an executable, including imported executables (backward compatibility)\n */\nexport function isExecutableVariable(variable: Variable): boolean {\n  return AdvancedTypeDetection.isExecutableVariable(variable);\n}\n\n/**\n * Get the effective type of a variable, considering imported variables (backward compatibility)\n */\nexport function getEffectiveType(variable: Variable) {\n  return AdvancedTypeDetection.getEffectiveType(variable);\n}"]}