{"version":3,"sources":["../interpreter/eval/import/VariableImporter.ts"],"names":[],"mappings":"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","file":"chunk-B5K53GVD.mjs","sourcesContent":["import type { DirectiveNode } from '@core/types';\nimport type { Variable, VariableSource, VariableTypeDiscriminator, ExecutableVariable, TemplateVariable } from '@core/types/variable';\nimport { \n  createImportedVariable, \n  createObjectVariable,\n  createArrayVariable,\n  createSimpleTextVariable,\n  createPathVariable,\n  createExecutableVariable,\n  createTemplateVariable,\n  createStructuredValueVariable,\n  isExecutable,\n  isExecutableVariable,\n  getEffectiveType,\n  VariableTypeGuards\n} from '@core/types/variable';\nimport { isStructuredValue } from '@interpreter/utils/structured-value';\nimport type { Environment } from '../../env/Environment';\nimport { ObjectReferenceResolver } from './ObjectReferenceResolver';\nimport { MlldImportError } from '@core/errors';\nimport type { ShadowEnvironmentCapture } from '../../env/types/ShadowEnvironmentCapture';\nimport { ExportManifest } from './ExportManifest';\nimport { astLocationToSourceLocation } from '@core/types';\nimport type { SourceLocation } from '@core/types';\n\nexport interface ModuleProcessingResult {\n  moduleObject: Record<string, any>;\n  frontmatter: Record<string, any> | null;\n  childEnvironment: Environment;\n}\n\n/**\n * Handles variable creation, type inference, and environment merging for imports\n */\nexport class VariableImporter {\n  constructor(private objectResolver: ObjectReferenceResolver) {}\n  \n  /**\n   * Serialize shadow environments for export (Maps to objects)\n   * WHY: Maps don't serialize to JSON, so we convert them to plain objects\n   * GOTCHA: Function references are preserved directly\n   */\n  private serializeShadowEnvs(envs: ShadowEnvironmentCapture): any {\n    const result: any = {};\n    \n    for (const [lang, shadowMap] of Object.entries(envs)) {\n      if (shadowMap instanceof Map && shadowMap.size > 0) {\n        // Convert Map to object\n        const obj: Record<string, any> = {};\n        for (const [name, func] of shadowMap) {\n          obj[name] = func;\n        }\n        result[lang] = obj;\n      }\n    }\n    \n    return result;\n  }\n  \n  /**\n   * Deserialize shadow environments after import (objects to Maps)\n   * WHY: Shadow environments are expected as Maps internally\n   */\n  private deserializeShadowEnvs(envs: any): ShadowEnvironmentCapture {\n    const result: ShadowEnvironmentCapture = {};\n\n    for (const [lang, shadowObj] of Object.entries(envs)) {\n      if (shadowObj && typeof shadowObj === 'object') {\n        // Convert object to Map\n        const map = new Map<string, any>();\n        for (const [name, func] of Object.entries(shadowObj)) {\n          map.set(name, func);\n        }\n        result[lang as keyof ShadowEnvironmentCapture] = map;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Checks whether the requested alias has already been claimed during the\n   * current import pass and throws a detailed error when a collision exists.\n   */\n  private ensureImportBindingAvailable(\n    targetEnv: Environment,\n    name: string,\n    importSource: string,\n    location?: SourceLocation\n  ): void {\n    if (!name || name.trim().length === 0) return;\n    const existingBinding = targetEnv.getImportBinding(name);\n    if (!existingBinding) {\n      return;\n    }\n\n    throw new MlldImportError(\n      `Import collision - '${name}' already imported from ${existingBinding.source}. Alias one of the imports.`,\n      {\n        code: 'IMPORT_NAME_CONFLICT',\n        context: {\n          name,\n          existingSource: existingBinding.source,\n          attemptedSource: importSource,\n          existingLocation: existingBinding.location,\n          newLocation: location,\n          suggestion: \"Use 'as' to alias one of the imports\"\n        },\n        details: {\n          filePath: location?.filePath || existingBinding.location?.filePath,\n          variableName: name\n        }\n      }\n    );\n  }\n\n  /**\n   * Writes the variable and persists the associated binding only after the\n   * assignment succeeds, preventing partially-applied imports from polluting\n   * the collision tracking map.\n   */\n  private setVariableWithImportBinding(\n    targetEnv: Environment,\n    alias: string,\n    variable: Variable,\n    binding: { source: string; location?: SourceLocation }\n  ): void {\n    let shouldPersistBinding = false;\n    try {\n      targetEnv.setVariable(alias, variable);\n      shouldPersistBinding = true;\n    } finally {\n      if (shouldPersistBinding) {\n        targetEnv.setImportBinding(alias, binding);\n      }\n    }\n  }\n\n  /**\n   * Serialize module environment for export (Map to object)\n   * WHY: Maps don't serialize to JSON, so we need to convert to exportable format\n   * IMPORTANT: Use the exact same serialization as processModuleExports to ensure compatibility\n   */\n  private serializeModuleEnv(moduleEnv: Map<string, Variable>): any {\n    // Create a temporary childVars map and reuse processModuleExports logic\n    // Skip module env serialization to prevent infinite recursion\n    const tempResult = this.processModuleExports(moduleEnv, {}, true);\n    return tempResult.moduleObject;\n  }\n\n  /**\n   * Deserialize module environment after import (object to Map)\n   * IMPORTANT: Reuse createVariableFromValue to ensure proper Variable reconstruction\n   */\n  deserializeModuleEnv(moduleEnv: any): Map<string, Variable> {\n    const result = new Map<string, Variable>();\n    if (moduleEnv && typeof moduleEnv === 'object') {\n      for (const [name, varData] of Object.entries(moduleEnv)) {\n        // Reuse the existing variable creation logic\n        const variable = this.createVariableFromValue(\n          name,\n          varData,\n          'module-env', // Use a special import path to indicate this is from module env\n          name\n        );\n        result.set(name, variable);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Import variables from a processing result into the target environment\n   */\n  async importVariables(\n    processingResult: ModuleProcessingResult,\n    directive: DirectiveNode,\n    targetEnv: Environment\n  ): Promise<void> {\n    const { moduleObject } = processingResult;\n    \n    // Handle variable merging based on import type\n    await this.handleImportType(directive, moduleObject, targetEnv, processingResult.childEnvironment);\n  }\n\n  /**\n   * Process module exports - either use explicit @data module or auto-generate\n   */\n  processModuleExports(\n    childVars: Map<string, Variable>,\n    parseResult: any,\n    skipModuleEnvSerialization?: boolean,\n    manifest?: ExportManifest | null\n  ): { moduleObject: Record<string, any>, frontmatter: Record<string, any> | null } {\n    // Extract frontmatter if present\n    const frontmatter = parseResult.frontmatter || null;\n\n    // Always start with auto-export of all top-level variables\n    const moduleObject: Record<string, any> = {};\n    const explicitNames = manifest?.hasEntries() ? manifest.getNames() : null;\n    const explicitExports = explicitNames ? new Set(explicitNames) : null;\n    if (explicitNames && explicitNames.length > 0) {\n      // Fail fast if the manifest references names that never materialised in\n      // the child environment so authors receive a precise directive pointer.\n      for (const name of explicitNames) {\n        if (!childVars.has(name)) {\n          const location = manifest?.getLocation(name);\n          throw new MlldImportError(\n            `Exported name '${name}' is not defined in this module`,\n            {\n              code: 'EXPORTED_NAME_NOT_FOUND',\n              context: {\n                exportName: name,\n                location\n              },\n              details: {\n                filePath: location?.filePath,\n                variableName: name\n              }\n            }\n          );\n        }\n      }\n    }\n    const shouldSerializeModuleEnv = !skipModuleEnvSerialization;\n    let moduleEnvSnapshot: Map<string, Variable> | null = null;\n    const getModuleEnvSnapshot = () => {\n      if (!moduleEnvSnapshot) {\n        moduleEnvSnapshot = new Map(childVars);\n      }\n      return moduleEnvSnapshot;\n    };\n    \n    // Export all top-level variables directly (except system variables)\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log(`[processModuleExports] childVars size: ${childVars.size}`);\n      console.log(`[processModuleExports] childVars keys: ${Array.from(childVars.keys()).join(', ')}`);\n    }\n    \n    for (const [name, variable] of childVars) {\n      if (explicitExports && !explicitExports.has(name)) {\n        continue;\n      }\n      // Only export legitimate mlld variables - this automatically excludes\n      // system variables like frontmatter (@fm) that don't have valid mlld types\n      if (!this.isLegitimateVariableForExport(variable)) {\n        if (process.env.MLLD_DEBUG === 'true') {\n          console.log(`[processModuleExports] Skipping non-legitimate variable '${name}' with type: ${variable.type}`);\n        }\n        continue;\n      }\n      // For executable variables, we need to preserve the full structure\n      if (variable.type === 'executable') {\n        const execVar = variable as ExecutableVariable;\n\n        // Serialize shadow environments if present (Maps don't serialize to JSON)\n        let serializedMetadata = { ...execVar.metadata };\n        if (serializedMetadata.capturedShadowEnvs) {\n          serializedMetadata = {\n            ...serializedMetadata,\n            capturedShadowEnvs: this.serializeShadowEnvs(serializedMetadata.capturedShadowEnvs)\n          };\n        }\n        // Serialize module environment if present\n        if (shouldSerializeModuleEnv) {\n          const capturedEnv = serializedMetadata.capturedModuleEnv instanceof Map\n            ? serializedMetadata.capturedModuleEnv\n            : getModuleEnvSnapshot();\n          serializedMetadata = {\n            ...serializedMetadata,\n            capturedModuleEnv: this.serializeModuleEnv(capturedEnv)\n          };\n        } else {\n          // Remove capturedModuleEnv to avoid recursion\n          delete serializedMetadata.capturedModuleEnv;\n        }\n        \n        // Export executable with all necessary metadata\n        moduleObject[name] = {\n          __executable: true,\n          value: execVar.value,\n          // paramNames removed - they're already in executableDef and shouldn't be exposed as imports\n          executableDef: execVar.metadata?.executableDef,\n          metadata: serializedMetadata\n        };\n      } else if (variable.type === 'template') {\n        const templateVar = variable as TemplateVariable;\n\n        moduleObject[name] = {\n          __template: true,\n          content: templateVar.value,\n          templateSyntax: templateVar.templateSyntax,\n          parameters: templateVar.parameters,\n          templateAst: templateVar.metadata?.templateAst || (Array.isArray(templateVar.value) ? templateVar.value : undefined)\n        };\n      } else if (variable.type === 'object' && typeof variable.value === 'object' && variable.value !== null) {\n        // For objects, resolve any variable references within the object\n        const resolvedObject = this.objectResolver.resolveObjectReferences(variable.value, childVars);\n        moduleObject[name] = resolvedObject;\n      } else {\n        // For other variables, export the value directly\n        moduleObject[name] = variable.value;\n      }\n    }\n    \n    return {\n      moduleObject,\n      frontmatter\n    };\n  }\n\n  /**\n   * Create a variable from an imported value, inferring the type\n   */\n  createVariableFromValue(\n    name: string,\n    value: any,\n    importPath: string,\n    originalName?: string\n  ): Variable {\n    const source: VariableSource = {\n      directive: 'var',\n      syntax: Array.isArray(value) ? 'array' : \n              (value && typeof value === 'object') ? 'object' : 'quoted',\n      hasInterpolation: false,\n      isMultiLine: false\n    };\n    \n    const metadata = {\n      isImported: true,\n      importPath,\n      originalName: originalName !== name ? originalName : undefined,\n      definedAt: { line: 0, column: 0, filePath: importPath }\n    };\n\n    if (isStructuredValue(value)) {\n      return createStructuredValueVariable(\n        name,\n        value,\n        source,\n        {\n          ...metadata,\n          isStructuredValue: true,\n          structuredValueType: value.type\n        }\n      );\n    }\n    \n    // Check if this is an executable export\n    if (value && typeof value === 'object' && '__executable' in value && value.__executable) {\n      return this.createExecutableFromImport(name, value, source, metadata);\n    }\n    \n    // Check if this is a template export\n    if (value && typeof value === 'object' && (value as any).__template) {\n      const templateSource: VariableSource = {\n        directive: 'var',\n        syntax: 'template',\n        hasInterpolation: true,\n        isMultiLine: true\n      };\n      const tmplMetadata = { ...metadata, templateAst: (value as any).templateAst };\n      return createTemplateVariable(\n        name,\n        (value as any).content,\n        (value as any).parameters,\n        (value as any).templateSyntax === 'tripleColon' ? 'tripleColon' : 'doubleColon',\n        templateSource,\n        tmplMetadata\n      );\n    }\n\n    // Infer the variable type from the value\n    const originalType = this.inferVariableType(value);\n\n    // Convert non-string primitives to strings\n    let processedValue = value;\n    if (typeof value === 'number' || typeof value === 'boolean') {\n      processedValue = String(value);\n    }\n    \n    // For array types, create an ArrayVariable to preserve array behaviors\n    if (originalType === 'array' && Array.isArray(processedValue)) {\n      const isComplexArray = this.hasComplexContent(processedValue);\n\n      return createArrayVariable(\n        name,\n        processedValue,\n        isComplexArray,\n        source,\n        {\n          ...metadata,\n          isImported: true,\n          importPath,\n          originalName: originalName !== name ? originalName : undefined\n        }\n      );\n    }\n\n    // For object types, create an ObjectVariable to preserve field access capability\n    if (originalType === 'object') {\n      const normalizedObject = this.unwrapArraySnapshots(processedValue, importPath);\n      // Check if the object contains complex AST nodes that need evaluation\n      const isComplex = this.hasComplexContent(normalizedObject);\n      \n      return createObjectVariable(\n        name,\n        normalizedObject,\n        isComplex, // Mark as complex if it contains AST nodes\n        source,\n        {\n          ...metadata,\n          isImported: true,\n          importPath,\n          originalName: originalName !== name ? originalName : undefined\n        }\n      );\n    }\n    \n    // For non-objects, use createImportedVariable to preserve the original type info\n    return createImportedVariable(\n      name,\n      processedValue,\n      originalType,\n      importPath,\n      false,\n      originalName || name,\n      source,\n      metadata\n    );\n  }\n\n  private unwrapArraySnapshots(value: any, importPath: string): any {\n    if (Array.isArray(value)) {\n      return value.map(item => this.unwrapArraySnapshots(item, importPath));\n    }\n\n    if (value && typeof value === 'object') {\n      if ((value as any).__arraySnapshot) {\n        const snapshot = value as { value: any[]; metadata?: Record<string, any>; isComplex?: boolean; name?: string };\n        const source: VariableSource = {\n          directive: 'var',\n          syntax: 'array',\n          hasInterpolation: false,\n          isMultiLine: false\n        };\n        const arrayMetadata = {\n          ...(snapshot.metadata || {}),\n          isImported: true,\n          importPath,\n          originalName: snapshot.name\n        };\n        const normalizedElements = Array.isArray(snapshot.value)\n          ? snapshot.value.map(item => this.unwrapArraySnapshots(item, importPath))\n          : [];\n        const arrayName = snapshot.name || 'imported_array';\n        return createArrayVariable(arrayName, normalizedElements, snapshot.isComplex === true, source, arrayMetadata);\n      }\n\n      const result: Record<string, any> = {};\n      for (const [key, entry] of Object.entries(value)) {\n        result[key] = this.unwrapArraySnapshots(entry, importPath);\n      }\n      return result;\n    }\n\n    return value;\n  }\n\n  /**\n   * Create a namespace variable for imports with aliased wildcards (e.g., * as @config)\n   */\n  createNamespaceVariable(\n    alias: string, \n    moduleObject: Record<string, any>, \n    importPath: string\n  ): Variable {\n    const source: VariableSource = {\n      directive: 'var',\n      syntax: 'object',\n      hasInterpolation: false,\n      isMultiLine: false\n    };\n\n    // Check if the namespace contains complex content (like executables)\n    const isComplex = this.hasComplexContent(moduleObject);\n    \n    return createObjectVariable(\n      alias,\n      moduleObject,\n      isComplex, // Mark as complex if it contains AST nodes or executables\n      source,\n      {\n        isImported: true,\n        importPath,\n        isNamespace: true,\n        definedAt: { line: 0, column: 0, filePath: importPath }\n      }\n    );\n  }\n\n  /**\n   * Merge variables into the target environment based on import type\n   */\n  private async handleImportType(\n    directive: DirectiveNode,\n    moduleObject: Record<string, any>,\n    targetEnv: Environment,\n    childEnv: Environment\n  ): Promise<void> {\n    if (directive.subtype === 'importAll') {\n      throw new MlldImportError(\n        'Wildcard imports \\'/import { * }\\' are no longer supported. ' +\n        'Use namespace imports instead: \\'/import \"file\"\\' or \\'/import \"file\" as @name\\'',\n        directive.location,\n        {\n          suggestion: 'Change \\'/import { * } from \"file\"\\' to \\'/import \"file\"\\''\n        }\n      );\n    } else if (directive.subtype === 'importNamespace') {\n      await this.handleNamespaceImport(directive, moduleObject, targetEnv, childEnv);\n    } else if (directive.subtype === 'importSelected') {\n      await this.handleSelectedImport(directive, moduleObject, targetEnv, childEnv);\n    } else {\n      throw new Error(`Unknown import subtype: ${directive.subtype}`);\n    }\n  }\n\n  /**\n   * Handle namespace imports\n   */\n  private async handleNamespaceImport(\n    directive: DirectiveNode,\n    moduleObject: Record<string, any>,\n    targetEnv: Environment,\n    childEnv: Environment\n  ): Promise<void> {\n    // For shorthand imports, namespace is stored as an array in values.namespace\n    const namespaceNodes = directive.values?.namespace;\n    const alias = (namespaceNodes && Array.isArray(namespaceNodes) && namespaceNodes[0]?.content) \n      ? namespaceNodes[0].content \n      : directive.values?.imports?.[0]?.alias;\n\n    if (!alias) {\n      throw new Error('Namespace import missing alias');\n    }\n\n    const importerFilePath = targetEnv.getCurrentFilePath();\n    const aliasLocationNode = namespaceNodes && Array.isArray(namespaceNodes) ? namespaceNodes[0] : undefined;\n    const aliasLocation = aliasLocationNode?.location\n      ? astLocationToSourceLocation(aliasLocationNode.location, importerFilePath)\n      : astLocationToSourceLocation(directive.location, importerFilePath);\n\n    // Smart namespace unwrapping: If the module exports a single main object\n    // with a conventional name, unwrap it for better ergonomics\n    let namespaceObject = moduleObject;\n    \n    // Get the module name from the import path (for unwrapping heuristics)\n    const importRef = directive.values?.from?.[0]?.content || '';\n    const moduleName = importRef.split('/').pop()?.replace(/\\.mld$/, '') || '';\n    \n    // Check if there's a single export with the module name or common patterns\n    const exportKeys = Object.keys(moduleObject);\n    const commonNames = [moduleName, 'main', 'default', 'exports'];\n    \n    // If there's only one export, or if there's an export matching common patterns\n    if (exportKeys.length === 1) {\n      // Single export - use it directly\n      namespaceObject = moduleObject[exportKeys[0]];\n    } else {\n      // Multiple exports - check for common patterns\n      for (const name of commonNames) {\n        if (name && moduleObject[name] && typeof moduleObject[name] === 'object') {\n          // Found a main export object - check if it looks like the primary export\n          const mainExport = moduleObject[name];\n          const otherExports = exportKeys.filter(k => k !== name && !k.startsWith('_'));\n          \n          // If the main export has most of the functionality, use it\n          if (Object.keys(mainExport).length > otherExports.length) {\n            namespaceObject = mainExport;\n            break;\n          }\n        }\n      }\n    }\n    \n    const importPath = childEnv.getCurrentFilePath() || 'unknown';\n    const importDisplay = this.getImportDisplayPath(directive, importPath);\n    const bindingInfo = { source: importDisplay, location: aliasLocation };\n\n    this.ensureImportBindingAvailable(targetEnv, alias, importDisplay, aliasLocation);\n\n    // If the unwrapped object is a template export, create a template variable instead\n    if (namespaceObject && typeof namespaceObject === 'object' && (namespaceObject as any).__template) {\n      const templateVar = this.createVariableFromValue(alias, namespaceObject, importPath);\n      this.setVariableWithImportBinding(targetEnv, alias, templateVar, bindingInfo);\n      return;\n    }\n\n    // Create namespace variable with the (potentially unwrapped) object\n    const namespaceVar = this.createNamespaceVariable(\n      alias,\n      namespaceObject,\n      importPath\n    );\n    this.setVariableWithImportBinding(targetEnv, alias, namespaceVar, bindingInfo);\n  }\n\n  /**\n   * Handle selected imports\n   */\n  private async handleSelectedImport(\n    directive: DirectiveNode,\n    moduleObject: Record<string, any>,\n    targetEnv: Environment,\n    childEnv: Environment\n  ): Promise<void> {\n    const imports = directive.values?.imports || [];\n    const importPath = childEnv.getCurrentFilePath() || 'unknown';\n    const importDisplay = this.getImportDisplayPath(directive, importPath);\n    const importerFilePath = targetEnv.getCurrentFilePath();\n\n    for (const importItem of imports) {\n      const importName = importItem.identifier;\n      const alias = importItem.alias || importName;\n\n      if (!(importName in moduleObject)) {\n        throw new Error(`Import '${importName}' not found in module`);\n      }\n\n      const bindingLocation = importItem?.location\n        ? astLocationToSourceLocation(importItem.location, importerFilePath)\n        : astLocationToSourceLocation(directive.location, importerFilePath);\n      const bindingInfo = { source: importDisplay, location: bindingLocation };\n\n      this.ensureImportBindingAvailable(targetEnv, alias, importDisplay, bindingLocation);\n\n      const importedValue = moduleObject[importName];\n      const variable = this.createVariableFromValue(alias, importedValue, importPath, importName);\n\n      this.setVariableWithImportBinding(targetEnv, alias, variable, bindingInfo);\n    }\n  }\n\n  /**\n   * Produces a human-readable source string for error messages, stripping any\n   * quotes that appeared in the original directive.\n   */\n  private getImportDisplayPath(directive: DirectiveNode, fallback: string): string {\n    const raw = (directive as any)?.raw;\n    if (raw && typeof raw.path === 'string' && raw.path.trim().length > 0) {\n      const trimmed = raw.path.trim();\n      return trimmed.replace(/^['\"]|['\"]$/g, '');\n    }\n    return fallback;\n  }\n\n  /**\n   * Create an executable variable from import metadata\n   */\n  private createExecutableFromImport(\n    name: string,\n    value: any,\n    source: VariableSource,\n    metadata: any\n  ): ExecutableVariable {\n    // This is an executable variable - reconstruct it properly\n    const execValue = value.value;\n    const executableDef = value.executableDef;\n    // Get paramNames from executableDef where it's properly stored\n    const paramNames = executableDef?.paramNames || [];\n    \n    // The executable definition contains all the needed information\n    // We just need to create a dummy ExecutableVariable that preserves it\n    // The actual execution will use the executableDef from metadata\n    // OLD CODE that might lose metadata:\n    // return createExecutableVariable(\n    //   name,\n    //   value.value.type,\n    //   value.value.template || '',\n    //   value.value.paramNames || [],\n    //   value.value.language,\n    //   source,\n    //   metadata\n    // );\n    \n    // NEW CODE: Ensure all metadata is preserved\n    let originalMetadata = value.metadata || {};\n    \n    // Deserialize shadow environments if present\n    if (originalMetadata.capturedShadowEnvs) {\n      originalMetadata = {\n        ...originalMetadata,\n        capturedShadowEnvs: this.deserializeShadowEnvs(originalMetadata.capturedShadowEnvs)\n      };\n    }\n\n    // Deserialize module environment if present\n    if (originalMetadata.capturedModuleEnv) {\n      const deserializedEnv = this.deserializeModuleEnv(originalMetadata.capturedModuleEnv);\n\n      // IMPORTANT: Each executable in the module env needs to have access to the full env\n      // This allows command-refs to find their siblings\n      for (const [_, variable] of deserializedEnv) {\n        if (variable.type === 'executable' && variable.metadata) {\n          // Give each executable in the module env access to all siblings\n          variable.metadata.capturedModuleEnv = deserializedEnv;\n        }\n      }\n\n      originalMetadata = {\n        ...originalMetadata,\n        capturedModuleEnv: deserializedEnv\n      };\n    }\n    \n    const enhancedMetadata = {\n      ...metadata,\n      ...originalMetadata, // Preserve ALL original metadata including capturedShadowEnvs\n      isImported: true,\n      importPath: metadata.importPath,\n      executableDef // This is what actually matters for execution\n    };\n    \n    const execVariable = createExecutableVariable(\n      name,\n      'command', // Default type - the real type is in executableDef\n      '', // Empty template - the real template is in executableDef\n      paramNames,\n      undefined, // No language here - it's in executableDef\n      source,\n      enhancedMetadata\n    );\n    \n    return execVariable;\n  }\n\n  /**\n   * Check if a value contains complex AST nodes that need evaluation\n   */\n  private hasComplexContent(value: any): boolean {\n    if (value === null || typeof value !== 'object') {\n      return false;\n    }\n\n    // Imported variables already hold evaluated content; do not treat them as complex\n    if (this.isVariableLike(value)) {\n      return false;\n    }\n\n    // Check if this is an AST node with a type\n    if (value.type) {\n      return true;\n    }\n    \n    // Check if it has __executable objects (from resolved executables)\n    if (value.__executable) {\n      return true;\n    }\n    \n    // Recursively check arrays\n    if (Array.isArray(value)) {\n      return value.some(item => this.hasComplexContent(item));\n    }\n    \n    // Recursively check object properties\n    for (const prop of Object.values(value)) {\n      if (this.hasComplexContent(prop)) {\n        return true;\n      }\n    }\n    \n    return false;\n  }\n\n  private isVariableLike(value: any): boolean {\n    return value &&\n      typeof value === 'object' &&\n      typeof value.type === 'string' &&\n      'name' in value &&\n      'value' in value &&\n      'source' in value &&\n      'createdAt' in value &&\n      'modifiedAt' in value;\n  }\n\n  /**\n   * Infer variable type from value\n   */\n  private inferVariableType(value: any): VariableTypeDiscriminator {\n    if (isStructuredValue(value)) {\n      return 'structured';\n    } else if (Array.isArray(value)) {\n      return 'array';\n    } else if (value && typeof value === 'object') {\n      return 'object';\n    } else if (typeof value === 'string') {\n      return 'simple-text';\n    } else {\n      // Numbers, booleans, etc. convert to text\n      return 'simple-text';\n    }\n  }\n\n  /**\n   * Check if a variable is a legitimate mlld variable that can be exported/imported.\n   * System variables (marked with metadata.isSystem) are excluded from exports to prevent\n   * namespace collisions when importing multiple modules with system variables like @fm.\n   */\n  private isLegitimateVariableForExport(variable: Variable): boolean {\n    // System variables (like @fm) should not be exported\n    if (variable.metadata?.isSystem) {\n      return false;\n    }\n    \n    // All user-created variables are exportable\n    // This includes variables created by /var, /exe, /path directives\n    return true;\n  }\n}\n"]}