{"version":3,"sources":["../interpreter/utils/type-guard-helpers.ts","../interpreter/utils/display-formatter.ts","../interpreter/utils/display-materialization.ts","../interpreter/utils/guard-inputs.ts","../interpreter/eval/directive-replay.ts","../interpreter/eval/directive-inputs.ts","../core/types/hooks.ts","../interpreter/hooks/hook-decision-handler.ts","../interpreter/eval/path.ts","../core/security/taint.ts","../interpreter/streaming/adapter-registry.ts","../interpreter/streaming/stream-format.ts","../interpreter/utils/structured-exec.ts","../interpreter/utils/shell-value.ts","../interpreter/utils/working-directory.ts","../interpreter/eval/run.ts","../interpreter/eval/import/ImportPathResolver.ts","../core/registry/utils/HashUtils.ts","../interpreter/eval/import/ImportSecurityValidator.ts","../interpreter/eval/import/ExportManifest.ts","../interpreter/eval/import/ModuleContentProcessor.ts","../interpreter/eval/import/ObjectReferenceResolver.ts","../core/policy/union.ts","../interpreter/eval/import/ImportDirectiveEvaluator.ts","../interpreter/eval/import/index.ts","../interpreter/utils/value-combine.ts","../interpreter/eval/when.ts","../interpreter/eval/data-values/EvaluationStateManager.ts","../interpreter/eval/data-values/PrimitiveEvaluator.ts","../interpreter/eval/data-values/CollectionEvaluator.ts","../interpreter/eval/data-values/VariableReferenceEvaluator.ts","../interpreter/eval/data-values/ForeachCommandEvaluator.ts","../interpreter/eval/data-values/ForeachSectionEvaluator.ts","../interpreter/eval/load-content.ts","../interpreter/eval/ast-extractor.ts","../interpreter/eval/pipeline/state-machine.ts","../interpreter/utils/json-to-xml.ts","../interpreter/utils/pipeline-input.ts","../interpreter/eval/pipeline/context-builder.ts","../interpreter/eval/output-shared.ts","../interpreter/eval/append.ts","../interpreter/eval/pipeline/builtin-effects.ts","../interpreter/eval/pipeline/rate-limit-retry.ts","../interpreter/utils/parallel.ts","../interpreter/utils/evaluator-result.ts","../interpreter/eval/helpers/parallel-exec.ts","../interpreter/eval/expressions.ts","../interpreter/eval/while.ts","../interpreter/eval/pipeline/executor.ts","../interpreter/eval/pipeline/builtin-transformers.ts","../interpreter/eval/pipeline/effects-attachment.ts","../interpreter/eval/pipeline/unified-processor.ts","../interpreter/eval/content-loader.ts","../interpreter/eval/data-values/LoadContentEvaluator.ts","../interpreter/eval/data-values/DataValueEvaluator.ts","../interpreter/eval/data-value-evaluator.ts","../interpreter/eval/output.ts","../interpreter/utils/foreach.ts","../interpreter/eval/show.ts","../interpreter/eval/var.ts","../interpreter/eval/helpers/shadowEnvResolver.ts","../interpreter/eval/exe.ts","../interpreter/eval/when-expression.ts","../interpreter/eval/for.ts","../interpreter/eval/export.ts","../interpreter/eval/guard.ts","../core/policy/needs.ts","../interpreter/eval/needs.ts","../interpreter/hooks/guard-retry-runner.ts","../interpreter/eval/policy.ts","../interpreter/eval/directive.ts","../interpreter/eval/conditional-inclusion.ts","../interpreter/utils/interpolation.ts","../interpreter/core/interpreter.ts","../interpreter/eval/expression.ts"],"names":["getTextContent","node","isTextNode","content","undefined","formatForDisplay","value","options","pretty","indent","separator","isForeachSection","String","isLoadContentResult","asText","isStructuredValue","data","Array","isArray","printableArray","map","item","normalizeArrayEntry","JSONFormatter","stringify","mx","source","Boolean","filename","url","text","every","join","materializeDisplayValue","descriptorSource","textOverride","provenanceSource","descriptor","getExpressionProvenance","extractSecurityDescriptor","recursive","mergeArrayElements","resolveNestedValue","preserve","preserveProvenance","resolveNestedValueInternal","isVariable","resolved","inheritIfNeeded","resolvedArray","entry","resolvedObject","key","Object","entries","target","inheritExpressionProvenance","FALLBACK_SOURCE","directive","syntax","hasInterpolation","isMultiLine","materializeGuardInputs","values","nameHint","normalized","materialized","materializeExpressionValue","name","fallback","createSimpleTextVariable","formatGuardInputValue","applyDescriptorFromValue","filter","materializeGuardInputsWithMapping","results","index","length","variable","push","JSON","makeSecurityDescriptor","updateVarMxFromDescriptor","mxCache","INLINE_SOURCE","replayStore","WeakMap","getReplayState","state","get","Map","set","ensureReplayEntry","env","invocation","existing","evaluateExecInvocation","result","materializeGuardVariable","fromProvenance","metadataSecurity","metadata","security","textValue","replayInlineExecInvocations","invocations","guardVariables","unique","from","Set","guardVariable","resolveDirectiveExecInvocation","clearDirectiveReplay","delete","extractDirectiveInputs","kind","extractShowInputs","extractOutputInputs","extractRunInputs","inlineInvocations","type","execInvocation","guardValues","inv","extractExecInvocationArgs","inputs","varName","resolveShowVariableName","getVariable","identifier","innerVar","legacyVariable","variableNode","sourceNode","findExecInvocation","hasArgs","args","subtype","resolveOutputVariableName","first","commandNodes","command","commandArray","interpolatedDescriptors","commandText","interpolate","InterpolationContext","ShellCommand","collectSecurityDescriptor","referencedVariables","collectVariablesFromNodes","referencedDescriptors","varMxToSecurityDescriptor","interpolationDescriptor","mergeSecurityDescriptors","mergedDescriptor","some","internal","isSystem","recordSecurityDescriptor","execRef","execName","resolveRunExecName","execVar","identifierNodes","commandRef","nodes","bucket","seen","WeakSet","visitNodeForVariables","candidate","typed","found","has","add","addVariableByIdentifier","objectReference","execArgs","arg","VariableMetadataUtils","attachContext","isDirectiveHookTarget","isExecHookTarget","isEffectHookTarget","DEFAULT_GUARD_MAX","afterRetryDebugEnabled","process","DEBUG_AFTER_RETRY","handleGuardDecision","decision","operationContext","action","guardName","reasonsArray","reasons","guardResults","hints","guardContextSnapshot","buildGuardContextFromMetadata","primaryReason","reason","info","guardFilter","scope","inputPreview","retryHint","hint","baseMessage","guardContext","guardInput","GuardError","operation","sourceLocation","extractNodeLocation","enforcePipelineGuardRetry","getGuardTransformedInputs","originalInputs","candidates","transformedInputs","variables","alignTransformedInputs","extras","pipelineContext","getPipelineContext","canRetryWithinPipeline","console","error","GuardRetrySignal","context","sourceRetryable","baseContext","trace","hintList","reasonList","attempt","try","max","resolvedReason","location","transformed","originals","aligned","limit","Math","min","i","replacement","original","cloned","evaluatePath","Error","identifierNode","pathNodes","path","pathNode","isURL","descriptors","interpolatedPath","merged","resolvedPath","resolverManager","getResolverManager","startsWith","pathParts","substring","split","potentialResolver","isResolverName","resolverContent","resolveModule","contentType","message","includes","resolvePath","replace","astLocationToSourceLocation","getCurrentFilePath","createPathVariable","definedAt","setVariable","dedupe","freezeArray","array","freeze","slice","TaintTracker","track","id","mergedSources","sources","mergedLabels","labels","mergedTaint","taint","snapshot","merge","snapshots","incoming","defaultSnapshot","flatMap","clear","isUrlLike","test","shouldTreatAsFile","sourceType","importType","deriveImportTaint","resolverName","toLowerCase","dirLabels","labelsForPath","explicitLabels","deriveCommandTaint","baseCommand","trim","BUILTIN_ADAPTERS","createClaudeCodeAdapter","createNDJSONAdapter","schemas","matchPath","matchValue","extract","chunk","AdapterRegistry","customAdapters","adapterCache","register","registerConfig","config","version","description","factory","adapter","getCached","list","builtins","keys","custom","getInfo","clearCache","unregister","adapterRegistry","getAdapter","isStreamAdapter","processChunk","flush","isAdapterConfig","resolveStreamFormatValue","evaluate","isExpression","resolveValue","ResolutionContext","Display","loadStreamAdapter","format","defaultSchema","wrapExecResult","ensureStructuredValue","wrapPipelineResult","classifyShellValue","looksLikeStructuredString","Buffer","isBuffer","toString","classifyStructuredValue","arrayType","elements","classifyArray","normalizeForJson","coerceValueForStdin","classification","asData","json","parse","val","fromEntries","trimmed","last","inner","createWorkingDirError","workingDirectory","MlldError","code","severity","ErrorSeverity","Recoverable","details","directiveType","resolveWorkingDirectory","workingDir","rawPath","FilePath","posix","isAbsolute","normalize","fs","getFileSystemService","exists","isDirectory","extractRawTextContent","parts","rawContent","dedentCommonIndent","src","lines","minIndent","line","match","l","resolveStdinInput","stdinSource","MLLD_DEBUG_STDIN","CommandExecution","evaluateRun","callStack","getIsImporting","outputValue","outputText","pendingOutputDescriptor","lastOutputDescriptor","mergePendingDescriptor","interpolateWithPendingDescriptor","interpolationContext","Default","targetEnv","setOutput","wrapped","existingDescriptor","hasSecurityVarMx","applySecurityDescriptorToStructuredValue","sourceNodeForPipeline","withClause","meta","streamingOptions","getStreamingOptions","streamingRequested","stream","streamingEnabled","enabled","pipelineId","Date","now","floor","random","hasStreamFormat","streamFormat","rawStreamFormat","streamFormatValue","setStreamingOptions","skipDefaultSinks","suppressTerminal","activeStreamingOptions","MLLD_DEBUG","streamingManager","getStreamingManager","configure","registry","getGuardRegistry","subtypeKey","afterGuards","getOperationGuardsForTiming","streamingMessage","timing","executionContext","directiveNode","filePath","preExtractedCommand","getPreExtractedRunCommand","effectiveWorkingDirectory","getExecutionDirectory","commandTaint","CMD_MAX","v","MLLD_MAX_SHELL_COMMAND_SIZE","n","Number","isFinite","cmdBytes","byteLength","MlldCommandExecutionError","exitCode","duration","stderr","e","getSecurityManager","securityManager","analyzer","commandAnalyzer","analysis","analyze","blocked","risks","stdinInput","stdin","commandOptions","input","executeCommand","codeNodes","argValues","AutoUnwrapManager","executeWithPreservation","extracted","extractVariableValue","unwrappedValue","unwrap","language","executeCode","commandName","fields","varRef","baseVar","variantMap","transformerVariants","remainingFields","firstField","variantName","variant","field","fieldName","__executable","fullName","f","capturedShadowEnvs","deserialized","lang","shadowObj","func","template","paramNames","createdAt","modifiedAt","executableDef","isExecutableVariable","getPreExtractedExec","definition","fullPath","paramName","argValue","tempEnv","createChild","setParameterVariable","cleanTemplate","commandTemplate","seg","idx","refExecVar","cycle","refDirective","commandArgs","codeParams","capturedEnvs","__capturedShadowEnvs","logger","debug","whenExprNode","codeTemplate","execEnv","evaluateWhenExpression","whenResult","normalizeWhenShowEffect","outputType","blockNode","evaluateExeBlock","blockResult","DEBUG_EXEC","interpolatedCode","templateOutput","executeProseExecutable","proseResult","pipeline","processPipeline","enableStage0","pipelineInput","valueForPipeline","isRetryable","sourceFunction","outputDescriptor","pipelineDescriptorHint","pipelineResult","descriptorHint","finalizedStreaming","finalizeResults","setStreamingResult","streaming","displayText","endsWith","isDataValue","isEmbedded","replacementNode","nodeId","addNode","shouldEmitFinalOutput","isRHSRef","materializedEffect","effectText","emitEffect","extractedInputs","ImportPathResolver","resolveImportPath","pathValue","normalizePathNodes","specialImport","detectSpecialImports","importPath","interpolatePathNodes","routeImportRequest","firstNode","isSpecial","dynamicResolver","findResolverForRef","potentialName","remainingPath","fullRef","interpolated","sectionNodes","section","sectionName","sectionDescriptors","mergedSection","handleModuleReference","handleURLImport","handleFileImport","potentialResolverName","moduleRef","expectedHash","extension","extractHashFromPath","moduleExtension","pathMeta","hash","hashIndex","lastIndexOf","isURLPath","handleLiberalImportSyntax","HashUtils","createHash","update","digest","integrity","verify","actualHash","verifyIntegrity","actualIntegrity","shortHash","fullHash","expandHash","availableHashes","matches","getCachePathComponents","prefix","rest","createModuleContent","timestamp","size","secureCompare","hash1","hash2","buffer1","buffer2","timingSafeEqual","ImportSecurityValidator","validateImportSecurity","resolution","validation","approved","hashValid","versionCompatible","circularImportDetected","errors","checkCircularImports","validateContentHash","isImporting","isTestMode","MLLD_SKIP_HASH_VALIDATION","shortActualHash","checkVersionCompatibility","frontmatterData","requiredVersion","MLLD_DEBUG_VERSION","currentMlldVersion","versionCheck","checkMlldVersion","compatible","moduleName","module","basename","formatVersionError","requestImportApproval","beginImport","endImport","validateModuleIntegrity","validateContentSecurity","ExportManifest","hasEntries","getNames","getEntries","getLocation","Symbol","iterator","toArray","ModuleContentProcessor","securityValidator","variableImporter","processModuleContent","getSecuritySnapshot","importDescriptor","mergeDescriptors","policyContext","policy","securityLabels","fileDescriptor","combinedDescriptor","processTemplateCollection","lowerPath","MlldImportError","suggestedName","ns","namespace","firstImport","imports","alias","example","readContentFromSource","cacheSource","parsed","processedContent","isPlainText","templateSyntax","parseContentByType","processJSONContent","processPlainTextContent","processRawTemplate","processMLLDContent","processResolverContent","ref","lowerRef","log","isDynamicModule","moduleObject","frontmatter","childEnvironment","getCurrentVariables","fsService","readdir","extractParamNames","templateParams","baseDir","isDir","walkTemplateDirectory","childEnv","setCurrentFilePath","guardDefinitions","dir","root","stat","catch","isFile","sanitizeKey","childGroup","lower","relativePath","relative","buildTemplateExecutable","displayPath","ext","extname","fileContent","readFile","parseSync","startRule","templateNodes","err","buildTemplateAst","validateTemplateParameters","execDef","sourceDirective","templatePath","references","collectTemplateReferences","allowed","invalid","refs","forEach","child","withoutExt","sanitized","params","param","cacheDurationMs","fetchURL","forImport","hasModuleExtension","forceModuleParse","extractSectionContent","hasIsVirtual","isVirtual","isVirtualFS","mode","getDynamicModuleMode","inferMlldMode","parseResult","success","handleParseError","dirname","finalContent","finalSyntax","default","__template","templateAst","jsonData","sourceContent","ast","astLength","astTypes","extractAndValidateFrontmatter","createChildEnvironment","setFrontmatter","containsExportDirective","setExportManifest","evalResult","evaluateInChildEnvironment","childVars","childVarsSize","childVarNames","exportManifest","getExportManifest","guards","processModuleExports","__meta__","hasSubstantive","hasSubstantiveContent","moduleNeeds","getModuleNeeds","moduleWants","getModuleWants","getPolicyContext","templateContent","trimmedSource","trimStart","trimEnd","filtered","sectionRegex","RegExp","inSection","sectionLevel","sectionLines","headerMatch","regex","lastIndex","exec","parseError","errorMessage","start","importError","importParseError","file","parseFrontmatter","frontmatterNode","importDir","getBasePath","setModuleIsolated","setImporting","ObjectReferenceResolver","resolveObjectReferences","variableMap","resolveStrings","stringRefPattern","MLLD_DEBUG_FIX","hasFields","resolveVariableReference","properties","resolveASTObjectNode","resolveNestedStructures","referencedVar","originalValue","referencedVarType","availableVars","resolveExecutableReference","__arraySnapshot","serializedCtx","serializedInternal","serializeShadowEnvs","capturedModuleEnv","serializeModuleEnv","isComplex","envs","shadowMap","obj","moduleEnv","spreadNode","spreadValue","assign","appendFileSync","hasProperties","mergePolicyConfigs","base","normalizePolicyConfig","baseAllow","toAllowShape","allow","incomingAllow","mergedAllow","mergeAllowShapes","baseDeny","toDenyShape","deny","incomingDeny","mergedDeny","mergeDenyShapes","limits","mergeLimits","fromAllowShape","fromDenyShape","normalizeLimits","raw","vals","shape","a","b","aSet","bSet","intersection","maxTokens","POSITIVE_INFINITY","timeout","MODULE_SOURCE_EXTENSIONS","DIRECTORY_INDEX_FILENAME","DEFAULT_DIRECTORY_IMPORT_SKIP_DIRS","matchesModuleExtension","ImportDirectiveEvaluator","pathResolver","contentProcessor","objectResolver","VariableImporter","evaluateImport","importContext","resolveImportType","baseDescriptor","taintSnapshot","taintDescriptor","withPolicyOverride","handleImportError","evaluateInputImport","evaluateResolverImport","evaluateModuleImport","evaluateFileImport","importDirective","declaredType","cachedDuration","validateDeclaredImportType","preferLocal","resolvedType","inferImportType","durationToMilliseconds","inferResolverImportType","isAllowedResolver","multipliers","seconds","minutes","hours","days","weeks","years","unit","resolver","getResolver","requestedImports","imp","resolve","exportData","importResolverVariables","toUpperCase","capabilities","contexts","import","ResolverError","unsupportedCapability","resolverResult","importFromResolverContent","getResolverExportData","fallbackResolverData","hasLocalModule","Fatal","reference","buildModuleCandidates","lastError","treatAsModule","validateLockFileVersion","directoryResult","maybeProcessDirectoryImport","processingResult","validateModuleResult","importVariables","applyPolicyImportContext","processDirectoryImport","skipDirs","getDirectoryImportSkipDirs","shouldSkipDirectory","indexPath","hasIndex","indexStat","childResolution","childResult","enforceModuleNeeds","sanitizeDirectoryKey","parseStringArrayOption","option","coerced","coerceStringLiteral","isArrayLiteralAst","items","valueType","hasOnlyLiteralOrText","dirName","patterns","pattern","minimatch","dot","contentLength","firstChars","processingRef","moduleObjectKeys","moduleObjectSize","hasFrontmatter","dynamicSource","childVariables","getAllVariables","parentVariables","exportedNames","exports","provenance","isProvenanceEnabled","buildDynamicImportProvenance","emitSDKEvent","tainted","importNode","getExportData","resolvedResult","sourcePath","importItem","createVariableFromValue","baseRef","extractSection","registrySource","moduleMatch","resolvedVersion","registryManager","getRegistryManager","lockFile","getLockFile","lockEntry","getImport","registryVersion","warn","normalizedSource","overrideConfig","previousContext","mergedConfig","configs","nextContext","tier","activePolicies","setPolicyContext","isPolicyImport","validateExportBindings","needs","unmet","findUnmetNeeds","detailLines","valueSegment","capability","label","sh","isCommandAvailable","cmd","collectCommandNames","packages","basePath","cwd","moduleDir","ecosystem","pkg","isNodePackageAvailable","isRuntimeAvailable","cmdNeeds","commands","binary","platform","spawnSync","stdio","status","esmRequire","createRequire","paths","exportKeys","missing","evaluator","isPlainObject","getPrototypeOf","prototype","combineValues","targetName","targetValue","sourceValue","sourceArray","rhsNumber","toNumber","isNaN","MlldDirectiveError","typeName","DENIED_KEYWORD","evaluateAssignmentValue","tail","handledByRunEvaluator","wrapperType","firstValue","evaluateCodeExecution","commandNode","runDirective","interpolatedCommand","processCommandOutput","isRawPrimitive","valueResult","evaluateLetAssignment","importer","newEnv","evaluateAugmentedAssignment","isolationRoot","findIsolationRoot","MlldWhenExpressionError","owner","findVariableOwner","isDescendantEnvironment","rhsValue","existingValue","combined","updatedVar","getParent","updateVariable","current","__parallelIsolationRoot","ancestor","compareValues","expressionValue","conditionValue","Equality","isTruthy","preview","evaluateWhen","isWhenSimpleNode","evaluateWhenSimple","isWhenMatchNode","evaluateWhenMatch","isWhenBlockNode","evaluateWhenBlock","MlldConditionError","conditionResult","evaluateCondition","condition","DEBUG_WHEN","validateNonePlacement","conditions","expression","expressionResult","isLetAssignment","isAugmentedAssignment","conditionPairs","isConditionPair","anyNonNoneMatched","pair","isNoneCondition","isNegated","actualCondition","unaryNode","operator","operand","execResult","actionNodes","actionNode","mergeChild","modifier","expressionNodes","variableName","hasVariable","evaluateFirstMatch","evaluateAllMatches","parentNodes","childNodes","childInitialCount","initialNodeCount","resultEnvNodes","parentEnvNodes","resultValue","blockAction","allMatch","envNodesBefore","envNodesAfter","actionResult","deniedContext","getContextManager","peekDeniedContext","deniedState","denied","whenCondition","negated","isDeniedLiteralNode","innerCondition","innerResult","evaluateUnifiedExpression","op","lhs","left","argument","rhs","right","consequent","originalError","count","firstExample","conditionIndex","truthy","nodeType","execNode","modifiedExecNode","stdout","finalValue","Truthiness","isCondition","whenValue","actualValue","trimmedStdout","isDeniedField","conditionTargetsDenied","visited","stack","pop","isTextLike","str","isArrayVariable","isObjectVariable","isCommandResult","isPipelineInput","assertStructuredValue","structuredData","foundNone","foundWildcard","EvaluationStateManager","evaluationCache","getCachedResult","cached","evaluated","hit","setCachedResult","getCacheStats","removeCacheEntry","isCached","interpolateAndRecord","PrimitiveEvaluator","stateManager","canHandle","isPrimitiveValue","isDirectiveValue","flags","contentArray","hasOnlyLiteralsOrText","itemTypes","evaluateCommandObject","evaluateDirective","commandStr","CollectionEvaluator","evaluateDataValue","isTemplateContent","evaluateObject","evaluateArray","evaluatePlainObject","evaluatedObj","suppressErrors","unwrapStructuredPrimitive","createPropertyError","isConditionalOmissionError","spreadVariable","fieldResult","accessFields","preserveContext","propValue","evaluatedElements","evaluateConditionalInclusion","shouldInclude","valueNode","evaluatedValue","evaluatedItem","createElementError","__error","__message","__property","__index","evaluatedObject","FieldAccessError","VariableReferenceEvaluator","isVariableReferenceValue","isTemplateValue","evaluateRawVariableReference","evaluateVariableReferenceWithTail","evaluateVariableReference","evaluateRunExec","evaluatePathNode","isExecutable","hasFieldAccess","resolveVariable","FieldAccess","attachProvenance","indexNode","indexValue","resolvedField","accessField","nestedVar","isPath","isImported","isObject","DataStructure","variableIdentifier","resultType","resultKeys","resultIsNull","resultIsUndefined","variableType","indexVar","nodeWithoutPipeline","pipelineResultType","isStructuredValueVariable","segments","fileSystem","ForeachCommandEvaluator","evaluateForeachCommand","foreachExpr","validateForeachExpression","ForeachSectionEvaluator","evaluateForeachSection","alligator","arrayVariable","pathField","actualArrayVariable","actualPathField","actualPath","part","arrayVar","arrayValue","itemVar","createArrayVariable","isParameter","isFullyEvaluated","createObjectVariable","sectionToProcess","sectionValue","llmxmlInstance","sectionContent","titleWithoutHash","getSection","includeNested","extractSectionBasic","templateResult","itemInfo","k","LoadContentResultImpl","absolute","_extension","_metrics","_fm","_fmParsed","_json","_jsonParsed","_rawContent","fm","contentToParse","fmMatch","yaml","load","ensureMetrics","buildTokenMetrics","tokest","tokens","metrics","self","valueOf","toPrimitive","toJSON","LoadContentResultURLImpl","urlPath","URL","pathname","domain","title","headers","hostname","_extractHtmlMetadata","html","dom","JSDOM","window","document","body","textContent","md","doc","titleElement","querySelector","ogTitle","twitterTitle","getAttribute","descElement","_extractHtmlMetadataFallback","titleMatch","descMatch","LoadContentResultHTMLImpl","_rawHtml","rawHtml","TYPE_FILTER_MAP","fn","var","class","interface","enum","struct","trait","isWildcardPattern","createSymbolMatcher","regexPattern","matchesTypeFilter","defType","allowedTypes","hasNameListPattern","p","hasContentPattern","getLinesAndOffsets","offsets","pos","extractAst","definitions","extractPythonDefinitions","extractRubyDefinitions","extractGoDefinitions","extractRustDefinitions","extractJavaDefinitions","extractSolidityDefinitions","extractCppDefinitions","extractCSharpDefinitions","extractTsDefinitions","definitionMap","sequence","toResult","def","keyOf","end","contains","container","pushDefinition","existingKey","findIndex","splice","usage","m","usageMatches","escapeRegExp","search","filteredUsages","other","patternName","matcher","d","filteredMatches","find","legacyPattern","extractNames","nestedTypes","names","sort","sourceFile","ts","createSourceFile","ScriptTarget","Latest","defs","stmt","statements","isFunctionDeclaration","makeTsDefinition","isClassDeclaration","member","members","isMethodDeclaration","isIdentifier","isInterfaceDeclaration","isEnumDeclaration","isTypeAliasDeclaration","isVariableStatement","decl","declarationList","declarations","sf","getStart","getEnd","getLineAndCharacterOfPosition","getText","blockEnd","startLine","currentIndent","$1","endLine","j","innerIndent","innerTrim","mName","mEnd","mStart","mEndPos","mCode","mSearch","contextStack","depth","clean","openers","doMatches","endMatches","makeDefinition","overrideName","finalName","rawLine","classMatch","parentSegments","classSegments","qualified","moduleSegments","defMatch","insideClass","constMatch","braces","started","opens","closes","fnMatch","structMatch","enumMatch","traitMatch","bodyStart","indexOf","bodyEnd","methodMatch","mEndLine","funcMatch","typeMatch","varMatch","strippedLines","inBlockComment","char","next","sanitize","pushBlockDefinition","pushVariable","classStack","pendingFunction","braceDepth","currentClass","resetPending","appendPending","signature","parsePending","parenIndex","before","namePart","className","maybeFunctionStart","stripped","sanitizedLine","cleaned","contractMatch","innerLine","innerClean","beforeDepth","memberName","memberType","modifierMatch","eventMatch","errorMatch","freeFnMatch","globalStructMatch","interfaceMatch","modifierSet","keywordBlockers","stripAttributes","close","skipModifiers","noComment","startIndex","keyword","recordKind","nameToken","innerNoComment","innerSignature","beforeTokens","candidateRaw","equalIndex","PipelineStateMachine","totalStages","isStage0Retryable","hasStage0Replay","maxRetriesPerContext","maxGlobalRetriesPerStage","stage0Exhausted","stage0BaseOutput","stage0BaseStructuredOutput","stage0RetryConsumed","initialState","currentStage","currentInput","baseInput","currentStructuredInput","baseStructuredInput","events","stageStructuredOutputs","activeRetryContext","globalStageRetryCount","allRetryHistory","getTotalStages","getEvents","getStatus","getAllRetryHistory","contextId","attempts","cloneStructuredValue","transition","handleStart","structuredInput","handleStageResult","handleAbort","initialStructured","recordEvent","output","stage","buildStageContext","handleStageSuccess","structuredOutput","handleStageRetry","handleStageError","wrappedStructured","wrapStructured","retryingStage","allAttempts","currentHint","nextStage","requestingStage","fromOverride","targetStage","hasActiveContext","contextRequestingStage","contextRetryingStage","willReuseContext","advanceToNextStage","globalRetries","attemptNumber","generateContextId","hintSuffix","toStore","retryInput","getInputForStage","retryStructuredInput","getStructuredInputForStage","previousOutputs","previousStructuredOutputs","structuredOutputsRecord","s","event","structured","stageHistory","stageHistoryStructured","contextAttempt","allAttemptsLength","willUseAttempt","globalStageRetries","totalRetries","globalAttempt","history","outputs","out","structuredOutputs","hintHistory","historyStructured","substr","clone","toScreamingSnakeCase","escapeXml","jsonToXml","rootTag","convertValue","tagName","tag","parseCsv","inQuotes","parseXml","wrapWithMetadata","extra","defineProperty","enumerable","configurable","buildPipelineStructuredValue","normalizedFormat","csv","MlldInterpreterError","xml","structuredType","createStageEnvironment","hasSyntheticSource","structuredAccess","rawId","rawIdentifier","userVisibleStage","userVisibleTotalStages","normalizedHint","isPlain","call","pipelineContextSnapshot","currentCommand","attemptCount","attemptHistory","getPipelineGuardHistory","capturePipelineContext","skipSetPipelineContext","setPipelineContext","stageEnv","pipelineInputWrapper","setSimplifiedInputVariable","setSimplifiedPipelineVariable","inputSource","inputVar","pipelineInputObj","createPipelineInputVariable","isPipelineParameter","structuredVar","createStructuredValueVariable","createSimplifiedPipelineContext","pipelineVar","isPipelineContext","guardHistoryProvider","internalStage","historyLength","toStructured","stageIndex","getStageOutput","baseWrapper","stageWrappers","userVisibleWrappers","triesText","structuredTries","tries","wrapper","all","mapped","formatJSONL","evaluateAppend","hasSource","sourceResult","evaluateOutputSource","rawValue","appendContentToFile","directiveKind","hasExplicitOutput","resolveAppendPath","payload","formatAppendPayload","appendFile","projectRoot","getProjectRoot","explicitFormat","treatAsJsonl","cause","formatted","ensureTrailingNewline","BUILTIN_EFFECTS","isBuiltinEffect","recordInterpolatedDescriptors","evaluateEffectArg","buildEffectOperationContext","effect","hasExplicitSource","isEffect","createEffectHookNode","resolveEffectPayload","stageOutput","usesExplicitSource","stageValue","stageText","extractEffectGuardInputs","guardInputs","convertEffectRetryToDeny","runBuiltinEffect","hookManager","getHookManager","hookNode","withOpContext","preDecision","runPre","resolvedInputs","isGuardRetrySignal","primaryInput","payloadVariable","payloadValue","effectResult","executeEffect","runPost","normalizedPayload","payloadText","materializedContent","writeFile","mkdir","varname","targetArgIndex","materializedPayload","finalPayload","RateLimitRetry","maxAttempts","baseDelay","wait","delay","Promise","res","setTimeout","reset","isRateLimitError","msg","getParallelLimit","MLLD_PARALLEL_LIMIT","parseInt","NaN","runWithConcurrency","run","opts","cap","ordered","paceMs","pacingChain","nextIndex","prev","release","worker","r","workers","createEvaluatorResult","mergeEvaluatorDescriptors","toPipelineCommand","rawArgs","executeParallelExecInvocations","executor","PipelineExecutor","executionResult","execute","returnStructured","evaluateBinaryExpression","evaluateUnaryExpression","evaluateTernaryExpression","evaluateArrayFilterExpression","evaluateArraySliceExpression","varResult","isExecParallel","leftResult","leftValue","leftTruthy","rightResult","isNullish","rightValue","equal","isEqual","leftNum","rightNum","ltResult","operandResult","operandValue","trueBranch","falseBranch","arrayResult","itemEnv","withVariable","passes","isUnifiedExpressionNode","evaluateArrayFilter","sleep","ms","normalizeState","setWhileInputVariable","resolveControlValue","iterEnv","currentState","unwrapped","controlPayload","controlKind","__whileControl","controlValue","isDoneLiteral","isContinueLiteral","evaluateWhileStage","invokeProcessor","rateMs","iteration","whileCtx","active","withExecutionContext","processor","resultEnv","control","pipelineCounter","createPipelineId","formatParallelStageError","prefixEnd","lineIndex","resetParallelErrorsContext","mxManager","popGenericContext","pushGenericContext","setLatestErrors","parallelCap","delayMs","stateMachine","sourceExecutedOnce","initialInputText","rateLimiter","initialOutput","finalOutput","lastStageIndex","debugStructured","MLLD_DEBUG_STRUCTURED","stageHookNodeCounter","bus","pipelineLength","pipelineStages","hasSourceFunction","pipelineHasStreamingStage","getBus","buildCommandExecutionContext","stageContext","parallelIndex","stageStreaming","isStageStreaming","streamId","emitStream","emit","st","initialInput","resetPipelineGuardHistory","initialWrapper","safeJSONStringify","applySourceDescriptor","stages","nextStep","stageId","clearStageOutputsFrom","inputLength","commandId","stageStartTime","stageEntry","executeParallelStage","executeSingleStage","isRetry","durationMs","getFinalOutput","teardown","pipelineSnapshot","stageDescriptor","parentPipelineContextPushed","logStructuredStage","prevOut","currOut","debugNormalize","previousStageOutput","cachedCurrentOutput","buildStageDescriptor","stageOpContext","createPipelineOperationContext","stageHookNode","createStageHookNode","executeStage","stageExecution","whileStage","whileResult","stateValue","processorCommand","buildWhileProcessorCommand","normalizedState","normalizeWhileInput","execution","executeInlineValueStage","executeInlineCommandStage","retry","isRetrySignal","parseRetryScope","parseRetryHint","normalizeOutput","finalizeStageOutput","labelDescriptor","metadataLabels","normalizedText","runInlineEffects","pmx","updatePipelineContext","runWithinPipeline","withOperation","withPipeContext","clearPipelineContext","firstTime","sourceOutput","fresh","freshWrapper","commandVar","resolveCommandReference","processArguments","bindParametersAutomatically","executeCommandVariable","stageInputs","buildCommandLabelDescriptor","runInline","normalizedResult","stageInput","setExpressionProvenance","fallbackId","evaluatedArgs","evaluatedArg","evaluateArgumentNode","inlineLabels","variableLabels","PipelineInput","unwrappedOutput","hookOptions","sharedStructuredInput","branchInput","subEnv","branchCtxManager","branchOpContext","branchHookNode","executeBranch","marker","extractStageValue","markerText","retrySignal","branchPayloads","aggregatedData","aggregatedText","aggregatedBase","stageDescriptors","getStructuredSecurityDescriptor","aggregatedDescriptor","aggregated","_structuredInput","logStructuredValue","normalizedArray","maybeText","rawOutput","descriptorHints","mergeStageDescriptors","normalizedValue","inputDescriptor","rawDescriptor","inputLabels","rawLabels","existingLabels","hintLabels","normalizedLabels","effects","effectCmd","fallbackText","startStage","phase","stageName","isParallelBranch","parallel","textSnippet","snippet","dataPreview","previewValue","typeofValue","sample","BUILTIN_TRANSFORMERS","isBuiltinTransformer","getBuiltinTransformers","t","attachBuiltinEffects","functional","pendingLeadingEffects","hadLeadingEffects","functionalPipeline","group","lowerName","requiresMeta","isInlineEffect","pcmd","prevCmd","streamRequested","getSourceFunctionFromValue","descriptorFromValue","descriptorFromAst","extractDescriptorFromAst","pipelineDescriptor","directiveLabels","debugPipelineDetection","detected","detectPipeline","hasDetected","hasValue","hasMetadata","normalizedPipeline","pipelineToValidate","validatePipeline","prepareInput","attachDescriptorToRetryInput","evaluateCommand","structuredEnabled","cachedInput","funcName","errorsMeta","processorName","getWhileProcessorName","getAvailableFunctions","prepareStructuredInput","incomingMetadata","providedDescriptor","sourceDescriptor","finalizeWrapper","mergedMetadata","normalizedData","sanitizeStructuredData","nested","normalizedObject","funcs","execDescriptor","objectSource","needsPipelineProcessing","pipes","isGlobPattern","getRelativeBasePath","getFileDirectory","formatRelativePath","targetPath","absoluteTarget","processContentLoader","expected","hasTransform","transform","hasPipes","pathOrUrl","actualSource","reconstructPath","reconstructUrl","isGlob","astPatterns","varValue","hasNames","hasContent","loadNameResults","namePattern","glob","followSymlinks","ignore","fileList","nameResults","piped","finalizeLoaderResult","loadAstResults","astResults","applyTemplateToAstResults","response","fetchURLWithMetadata","convertHtmlToMarkdown","isSectionListPattern","level","getSectionListLevel","sections","listSections","extractSectionName","renamed","pipedSection","urlResult","pipedContent","pipedResult","loadGlobPattern","transformedResults","applyTransformToResults","pipedResults","resolvedFilePath","fileSecurityDescriptor","securityMetadata","loadSingleFile","pipedString","DEBUG_CONTENT_LOADER","hasAngleBracket","resolvedPathOverride","markdownContent","fileContext","relativeBase","globCwd","globPattern","computeRelative","globError","hasVariables","reconstructed","segment","urlNode","protocol","host","sectionNode","identifierType","renamedTitle","llmxmlError","availableSections","getAvailableSections","finalTitle","processedParts","contentWithoutHeader","applyHeaderTransform","headings","getHeadings","h","headingLevel","reader","Readability","article","turndownService","TurndownService","headingStyle","codeBlockStyle","bulletListMarker","emDelimiter","strongDelimiter","turndown","markdown","byline","templateParts","isPlaceholder","transformedContent","wrapLoadContentValue","mergeMetadata","inferredType","inferLoaderType","deriveLoaderText","baseSecurity","extraSecurity","mergedSecurity","LoadContentEvaluator","DataValueEvaluator","primitiveEvaluator","collectionEvaluator","variableReferenceEvaluator","foreachCommandEvaluator","foreachSectionEvaluator","loadContentEvaluator","bind","valueTypeField","contextHint","originalMessage","wrappedError","getStateManager","getEvaluatorStats","cacheStats","cacheSize","cacheEntries","evaluatorTypes","dataValueEvaluator","getDataValueEvaluator","hasUnevaluatedDirectives","collectEvaluationErrors","propPath","elemPath","mergeInterpolatedDescriptors","evaluateOutput","targetType","effectHandler","getEffectHandler","getDocument","getNodes","formatOutput","formatError","applyOutputFormat","resolvedValue","securityDescriptor","bracketed","MlldOutputError","rawTarget","statePath","recordStateWrite","outputToFile","outputToStream","outputToEnv","outputToResolver","evaluateVariableSource","evaluateCommandSource","evaluateExecSource","evaluateInvocationSource","evaluateSimpleVariableSource","findExtractedVariable","paramVar","structuredWrapper","sourceFields","cmdName","cmdArgs","cmdVariable","isCommandVariable","cmdChildEnv","cmdResult","execInvocationNode","pathResult","dirPath","sourceVarName","resolverPath","looksLikeVariable","hintQuoted","hintExplain","DEFAULT_FOREACH_OPTIONS","evaluateForeachAsText","foreachExpression","normalizedResults","finalOptions","stringResults","normalizeForeachResultValue","templatedResults","VariableSource","templateSource","parseTemplateString","offset","column","parseForeachOptions","processEscapeSequences","isStructuredValueLike","entryValue","evaluateShow","skipJsonFormatting","hasErrorMetadata","isStreamingShow","interpolatedDescriptor","collectInterpolatedDescriptor","mergePipelineDescriptor","descriptorFromVariable","directiveLocation","invocationNode","extractedVar","getExtractedVariable","isTemplate","astArray","hasType","typeValue","hasItems","isComputed","override","globalThis","__mlldFetchOverride","resp","isPrimitive","fieldsToProcess","fieldTarget","processed","varType","valueKeys","hadFieldAccess","isNamespaceVariable","isNamespace","isStructured","valuePreview","settings","dataKeys","DEBUG_NAMESPACE","stringifyNamespace","valueLength","hasPipeline","sectionTitleNodes","sectionTitle","newTitleNodes","newTitle","newTitleTrimmed","newHeadingMatch","originalText","originalLevel","executePipeline","baseInvocation","isExecutableVar","templateNameNodes","templateName","arguments","foreach","with","loadContentNode","loadContent","loadResult","langNodes","tailPipeline","applyTailPipeline","parseAndWrapJson","preserveText","displayMaterialized","textForWrapper","invocationName","contentPreview","resultValueType","resultValueIsStructured","for","resultValueKeys","resultDescriptor","baseValue","wrapOptions","newHeader","newHeaderTrimmed","unshift","valueToString","createVariableSource","baseSource","primitiveType","interpolateAndCollect","mergeDescriptor","collected","prepareVarAssignment","capabilityKind","operationMetadata","resolvedSecurityDescriptor","mergeResolvedDescriptor","interpolateWithSecurity","extractSecurityFromValue","hasLabels","hasTaint","finalizeVariable","capabilityContext","createCapabilityContext","existingSecurity","finalMetadata","applySecurityMetadata","valueNodes","wc","hasWithClause","rawResult","structuredResult","hasComplexArrayItems","processedItems","evaluateArrayItem","hasComplexValues","processedObject","processedArray","itemCount","firstItem","nestedObj","nestedEntry","nestedKey","nestedValue","nestedData","includeTitle","asSection","varIdentifier","sourceVar","resolvedVar","VariableCopy","currentResult","parentPath","accessPath","finalVar","evalResultOverride","blockEnv","varWithTail","needsPipelineExtraction","evaluateForExpression","forResult","resolvedValueDescriptor","baseCtx","baseInternal","cloneFactoryOptions","overrides","applySecurityOptions","valueNodeType","resolvedValueType","MLLD_DEBUG_IDS","structuredInfo","dataType","resolvedValueName","structuredValueType","createPrimitiveVariable","resolvedValueIsArray","createCommandResultVariable","sourceCode","createComputedVariable","createFileContentVariable","createSectionContentVariable","structuredValue","structuredValueMetadata","expressionType","strValue","templateType","templateValue","createTemplateVariable","createInterpolatedTextVariable","skipPipeline","handledByRun","hasCtx","hasInternal","sourceNodeType","isPipelineResult","variableValue","evaluateVar","assignment","precomputedVarAssignment","objOrProperties","collectDescriptor","propertyKeys","sampleProperty","joined","nestedItems","nestedItem","ArrayElement","sectionFilePath","sectionFileContent","isFileLoadedValue","plainObj","resolveShadowEnvironment","currentEnv","normalizedLang","normalizeLanguage","captured","getShadowEnv","detectShadowConflicts","conflicts","capturedFunc","currentFunc","mergeShadowFunctions","block","returnValue","returnNode","return","hasReturnValue","returnNodes","returnResult","buildTemplateAstFromContent","evaluateExe","envRefs","environment","shadowFunctions","funcVar","createExecWrapper","effectiveWrapper","createSyncJsWrapper","setShadowEnv","hasShadowEnvs","captureAllShadowEnvs","isPipelineOnly","refName","commandRefNodes","refCandidate","isVariableRef","refFields","refPipes","shouldTemplateFromRef","isIdentity","workingDirMeta","dataNodes","dataTemplate","resolverNodes","payloadNodes","payloadTemplate","evaluatedPath","fallbackErr","renameNodes","rename","pathTemplate","sectionTemplate","renameTemplate","contentNodes","conditionCount","foreachNode","forExprNode","returnStmt","statementCount","hasReturn","configRefNodes","configRef","contentTemplate","hasConfig","captureModuleEnvironment","executableTypeForVariable","executableDescriptor","commandTaintDescriptor","metadataWithSecurity","createExecutableVariable","numValue","shadowEnv","paramSet","shadowNames","shadowValues","allParamNames","allParamValues","functionBody","trimmedCode","Function","stringValue","envVars","dataValue","cachedInterpolateFn","getInterpolateFn","normalizeActionValue","actionEnv","interpolateFn","evaluateControlLiteral","literal","denyMode","deniedHandlerRan","isFirstMode","boundIdentifier","hasBoundValue","boundValue","boundResult","setBoundValue","lastMatchValue","hasMatch","hasNonNoneMatch","hasValueProducingMatch","lastNoneValue","accumulatedEnv","buildResult","hasAnyAction","c","hasCodeExecution","rhsResult","conditionEnv","hasAction","matchedDeniedCondition","hintNodes","hintEnv","hintValue","firstAction","actionType","actionKind","actionSubtype","wrapperCandidate","Template","executionEnv","singleAction","__whenEffect","applyTailModifiers","actionError","conditionError","pipe","pipeEnv","pipelineStage","pipeResult","peekWhenExpressionType","actionTypes","looksLikeFileData","ensureVariable","formatFieldPath","enhanceFieldAccessError","pathSuffix","fieldPath","contextParts","enhancedDetails","iterationIndex","iterationKey","withIterationMxKey","formatIterationError","resetForErrorsContext","evaluateForDirective","varNode","varFields","fieldPathString","DEBUG_FOR","pushDirective","iterable","toIterable","receivedType","specified","forOptions","inherited","__forOptions","effective","iterableArray","forErrors","runOne","iterationRoot","derivedValue","accessed","iterationVar","derivedVar","keyVar","nodeWithFirst","outputContent","again","popDirective","expr","SKIP","exprResult","nodesToEvaluate","evaluateSequence","startEnv","lastResult","branchValue","looksLikeJsonString","orderedResults","finalResults","batchPipelineConfig","batchPipeline","batchStages","batchInput","isBatchInput","variableSource","sourceExpression","iterationVariable","hadBatchPipeline","evaluateExport","exportNodes","hasWildcard","guardRegistry","isGuard","getByName","manifest","emitter","evaluateGuard","guardNode","PACKAGE_ECOSYSTEM_ALIASES","js","python","py","ruby","rb","go","rust","BOOLEAN_CAPABILITY_ALIASES","bash","network","net","filesystem","ALLOW_ALL_POLICY","allowAll","normalizeNeedsDeclaration","rawObj","commandNeeds","normalizeCommandNeeds","bareCommands","normalizeBareCommands","__commands","packageKey","normalizePackages","specifier","booleanKey","mergeCommandNeeds","normalizeWantsDeclaration","tierObj","tierValue","why","allowedKeys","policySatisfiesNeeds","commandsAllowed","selectWantsTier","wants","granted","mergeNeedsDeclarations","mergedPackages","pkgs","normalizeStringArray","normalizeCommandMap","normalizeCommandDetail","wildcard","props","detail","methods","subcommands","parseVersionSpecifier","evaluateNeeds","needsRaw","recordModuleNeeds","evaluateWants","wantsRaw","recordModuleWants","getPolicyCapabilities","existingContext","logAfterRetryDebug","extractGuardRetryDetails","outputPreview","runWithGuardRetry","guardRetryContext","withGenericContext","debugPayload","rethrowPayload","denyPayload","evaluatePolicy","evaluateUnionExpression","mergePolicyConfigsFromArray","nameNode","policyName","recordPolicyConfig","resolvePolicyReference","resolvePolicyConfigSource","reduce","acc","extractTraceInfo","execId","execNameContent","pathContent","firstExport","policyNameNode","traceInfo","buildOperationContext","executeOnce","firstTransformed","mergedContext","mergeEvaluationContext","dispatchDirective","__guardTransformed","targetVar","getDirectiveTrace","markLastDirectiveFailed","directiveTrace","mlldTrace","baseMetadata","readStreamFlag","applyRunMetadata","applyImportMetadata","applyOutputMetadata","applyVarMetadata","applyShowMetadata","evaluationContext","runSubtype","summarizeNodes","commandPreview","outputTargetType","showSubtype","conditionNode","ASSERT_MODE","MLLD_ASSERT_ARRAY_BEHAVIOR","assertArrayBehavior","contextStr","createInterpolator","getDeps","interpolateImpl","withinDoubleQuotes","withinSingleQuotes","updateQuoteState","fragment","backslashCount","isEscaped","pushPart","extractInterpolationDescriptor","resolverVar","getResolverVariable","StringInterpolation","partsLength","strategy","EscapingStrategyFactory","getStrategy","escape","execOutput","wantsVarMx","resolutionContext","isReserved","isLazy","nodeValue","ResContext","escapeForSingleQuotes","escapeForDoubleQuotes","escapedElements","elem","quote","evaluatedArray","arrayLength","pathInterpolate","escapedValue","boundary","interpolateFileReference","sourceEval","bodyStr","showKind","LiteralNode","literalNode","FileReferenceNode","currentFile","getCurrentIterationFile","processFileFields","isFileInterpolationEnabled","isInInterpolationStack","pushInterpolationStack","sourceToUse","varMatches","hasVariableHint","contents","popInterpolationStack","nodeWithPipes","isDocument","isDirective","isText","isNewline","isComment","isFrontmatter","isCodeFence","isMlldRunBlock","isVariableReference","lastValue","emitIntent","visibility","collapsible","contentToInterpolate","interpolateWithSecurityRecording","evaluateDocument","evaluateText","hasValidLocation","loc","hasZeroOffset","typedDef","isInExpression","fieldAccessLocation","returnUndefinedForMissing","isExecInvocation","isLiteralNode","pipelineCtx","fileRefNode","rawLoadResult","hasRunKeyword","cleanNamespaceForDisplay","namespaceObject","executables","internalFields","hasExports","evaluateExpression","expressionContext","condResult","condTruthy","operandTruthy","aValue","extractValue","bValue","numA","numB","num"],"mappings":"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","file":"chunk-IA26UJYI.mjs","sourcesContent":["/**\n * Type guard helper utilities for safe AST node access\n * \n * These helpers provide safe ways to access properties on AST nodes\n * that may or may not exist, avoiding the need for inline type guards\n * throughout the codebase.\n */\n\nimport type { \n  MlldNode, \n  DirectiveNode, \n  TextNode, \n  VariableReferenceNode,\n  ContentNodeArray \n} from '@core/types';\nimport { \n  isDirectiveNode, \n  isTextNode, \n  isVariableReferenceNode \n} from '@core/types/guards';\n\n/**\n * Safely get the subtype of a directive node\n */\nexport function getDirectiveSubtype(node: MlldNode | undefined): string | undefined {\n  return node && isDirectiveNode(node) ? node.subtype : undefined;\n}\n\n/**\n * Safely get the identifier from a variable reference node\n */\nexport function getVariableIdentifier(node: MlldNode | undefined): string | undefined {\n  return node && isVariableReferenceNode(node) ? node.identifier : undefined;\n}\n\n/**\n * Safely get the content from a text node\n */\nexport function getTextContent(node: MlldNode | undefined): string | undefined {\n  return node && isTextNode(node) ? node.content : undefined;\n}\n\n/**\n * Check if a node is a directive with a specific subtype\n */\nexport function isDirectiveWithSubtype(node: MlldNode, subtype: string): node is DirectiveNode {\n  return isDirectiveNode(node) && node.subtype === subtype;\n}\n\n/**\n * Check if a node is a directive with a specific kind\n */\nexport function isDirectiveWithKind(node: MlldNode, kind: string): node is DirectiveNode {\n  return isDirectiveNode(node) && node.kind === kind;\n}\n\n/**\n * Get all text content from a content node array\n */\nexport function extractTextContent(nodes: ContentNodeArray): string {\n  return nodes\n    .filter(isTextNode)\n    .map(node => node.content)\n    .join('');\n}\n\n/**\n * Get all variable identifiers from a content node array\n */\nexport function extractVariableIdentifiers(nodes: ContentNodeArray): string[] {\n  return nodes\n    .filter(isVariableReferenceNode)\n    .map(node => node.identifier);\n}\n\n/**\n * Safely access directive values\n */\nexport function getDirectiveValues<T = any>(node: MlldNode | undefined): T | undefined {\n  return node && isDirectiveNode(node) ? (node.values as T) : undefined;\n}\n\n/**\n * Safely access directive metadata\n */\nexport function getDirectiveMeta<T = any>(node: MlldNode | undefined): T | undefined {\n  return node && isDirectiveNode(node) ? (node.meta as T) : undefined;\n}\n\n/**\n * Check if a value is a content node array\n */\nexport function isContentNodeArray(value: unknown): value is ContentNodeArray {\n  return Array.isArray(value) && value.every(item => \n    typeof item === 'object' && item !== null && 'type' in item\n  );\n}\n\n/**\n * Get the first text node content from an array\n */\nexport function getFirstTextContent(nodes: MlldNode[] | undefined): string | undefined {\n  if (!nodes) return undefined;\n  const textNode = nodes.find(isTextNode);\n  return textNode?.content;\n}\n\n/**\n * Get the first variable reference identifier from an array\n */\nexport function getFirstVariableIdentifier(nodes: MlldNode[] | undefined): string | undefined {\n  if (!nodes) return undefined;\n  const varNode = nodes.find(isVariableReferenceNode);\n  return varNode?.identifier;\n}\n\n/**\n * Check if a node array contains only text nodes\n */\nexport function isTextOnlyArray(nodes: MlldNode[]): nodes is TextNode[] {\n  return nodes.length > 0 && nodes.every(isTextNode);\n}\n\n/**\n * Check if a node array contains any variable references\n */\nexport function hasVariableReferences(nodes: MlldNode[]): boolean {\n  return nodes.some(isVariableReferenceNode);\n}\n\n/**\n * Safely get the string representation of a node\n */\nexport function getNodeString(node: MlldNode): string {\n  if (isTextNode(node)) {\n    return node.content;\n  }\n  if (isVariableReferenceNode(node)) {\n    return `@${node.identifier}`;\n  }\n  if (isDirectiveNode(node)) {\n    return `/${node.kind}`;\n  }\n  return node.type;\n}","import { JSONFormatter } from '../core/json-formatter';\nimport { isLoadContentResult } from '@core/types/load-content';\nimport { asText, isStructuredValue } from './structured-value';\n\nexport interface DisplayFormatOptions {\n  pretty?: boolean;\n  indent?: number;\n  separator?: string;\n  isForeachSection?: boolean;\n}\n\nexport function formatForDisplay(value: unknown, options: DisplayFormatOptions = {}): string {\n  const { pretty = true, indent = 2, separator = '\\n', isForeachSection = false } = options;\n\n  if (typeof value === 'string') {\n    return value;\n  }\n\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n\n  if (isLoadContentResult(value)) {\n    return asText(value);\n  }\n\n  if (isStructuredValue(value)) {\n    const data = value.data;\n\n    if (Array.isArray(data)) {\n      const printableArray = data.map(item => normalizeArrayEntry(item));\n      return JSONFormatter.stringify(printableArray, { pretty, indent });\n    }\n\n    if (data && typeof data === 'object') {\n      if (\n        value.mx?.source === 'load-content' ||\n        Boolean(value.mx?.filename) ||\n        Boolean(value.mx?.url)\n      ) {\n        return value.text;\n      }\n      return JSONFormatter.stringify(data, { pretty, indent });\n    }\n\n    if (typeof data === 'number' || typeof data === 'boolean') {\n      return String(data);\n    }\n\n    if (data === null) {\n      return 'null';\n    }\n\n    return value.text;\n  }\n\n  if (Array.isArray(value)) {\n    if (isForeachSection && value.every(item => typeof item === 'string')) {\n      return value.join('\\n\\n');\n    }\n    const printableArray = value.map(item => normalizeArrayEntry(item));\n    return JSONFormatter.stringify(printableArray, { pretty, indent });\n  }\n\n  if (value && typeof value === 'object') {\n    return JSONFormatter.stringify(value, { pretty, indent });\n  }\n\n  if (value === null || value === undefined) {\n    return '';\n  }\n\n  return String(value);\n}\n\nfunction normalizeArrayEntry(item: unknown): unknown {\n  if (isStructuredValue(item)) {\n    const data = item.data;\n    if (Array.isArray(data) || (data && typeof data === 'object')) {\n      return data;\n    }\n    if (typeof data === 'number' || typeof data === 'boolean' || data === null) {\n      return data;\n    }\n    return asText(item);\n  }\n  if (item && typeof item === 'object' && typeof (item as any).text === 'string') {\n    return (item as any).text;\n  }\n  return item;\n}\n","import type { SecurityDescriptor } from '@core/types/security';\nimport { formatForDisplay, type DisplayFormatOptions } from './display-formatter';\nimport { extractSecurityDescriptor, isStructuredValue } from './structured-value';\nimport { getExpressionProvenance, inheritExpressionProvenance } from './expression-provenance';\nimport { isVariable } from './variable-resolution';\n\nexport interface MaterializedDisplayValue {\n  text: string;\n  descriptor: SecurityDescriptor | undefined;\n}\n\nexport interface ResolveNestedValueOptions {\n  preserveProvenance?: boolean;\n}\n\nexport function materializeDisplayValue(\n  value: unknown,\n  options?: DisplayFormatOptions,\n  descriptorSource?: unknown,\n  textOverride?: string\n): MaterializedDisplayValue {\n  const provenanceSource = descriptorSource ?? value;\n  const descriptor =\n    getExpressionProvenance(provenanceSource) ??\n    extractSecurityDescriptor(provenanceSource, {\n      recursive: true,\n      mergeArrayElements: true\n    });\n  const text = textOverride !== undefined ? textOverride : formatForDisplay(value, options);\n  return { text, descriptor };\n}\n\nexport function resolveNestedValue(\n  value: unknown,\n  options?: ResolveNestedValueOptions\n): unknown {\n  const preserve = options?.preserveProvenance ?? false;\n  return resolveNestedValueInternal(value, preserve);\n}\n\nfunction resolveNestedValueInternal(value: unknown, preserve: boolean): unknown {\n  if (isVariable(value)) {\n    const resolved = resolveNestedValueInternal(value.value, preserve);\n    inheritIfNeeded(resolved, value, preserve);\n    return resolved;\n  }\n\n  if (isStructuredValue(value)) {\n    const resolved = resolveNestedValueInternal(value.data, preserve);\n    inheritIfNeeded(resolved, value, preserve);\n    return resolved;\n  }\n\n  if (Array.isArray(value)) {\n    const resolvedArray = value.map(entry => resolveNestedValueInternal(entry, preserve));\n    inheritIfNeeded(resolvedArray, value, preserve);\n    return resolvedArray;\n  }\n\n  if (value && typeof value === 'object') {\n    const resolvedObject: Record<string, unknown> = {};\n    for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {\n      resolvedObject[key] = resolveNestedValueInternal(entry, preserve);\n    }\n    inheritIfNeeded(resolvedObject, value, preserve);\n    return resolvedObject;\n  }\n\n  return value;\n}\n\nfunction inheritIfNeeded(target: unknown, source: unknown, preserve: boolean): void {\n  if (!preserve || !target || typeof target !== 'object') {\n    return;\n  }\n  inheritExpressionProvenance(target, source);\n}\n","import type { Variable, VariableSource } from '@core/types/variable';\nimport { createSimpleTextVariable } from '@core/types/variable';\nimport { materializeExpressionValue } from '@core/types/provenance/ExpressionProvenance';\nimport { isVariable } from './variable-resolution';\nimport { resolveNestedValue } from './display-materialization';\nimport { extractSecurityDescriptor } from './structured-value';\nimport { makeSecurityDescriptor } from '@core/types/security';\nimport { updateVarMxFromDescriptor } from '@core/types/variable/VarMxHelpers';\n\nconst FALLBACK_SOURCE: VariableSource = {\n  directive: 'var',\n  syntax: 'expression',\n  hasInterpolation: false,\n  isMultiLine: false\n};\n\nexport interface GuardInputOptions {\n  nameHint?: string;\n}\n\nexport interface GuardInputMappingEntry {\n  index: number;\n  variable: Variable;\n}\n\nexport function materializeGuardInputs(\n  values: readonly unknown[],\n  options?: GuardInputOptions\n): Variable[] {\n  const nameHint = options?.nameHint ?? '__guard_input__';\n  return values\n    .map(value => {\n      if (isVariable(value)) {\n        return value;\n      }\n      const normalized = resolveNestedValue(value, { preserveProvenance: true });\n      const materialized = materializeExpressionValue(normalized, { name: nameHint });\n      if (materialized) {\n        return materialized;\n      }\n      const fallback = createSimpleTextVariable(\n        nameHint,\n        formatGuardInputValue(normalized),\n        FALLBACK_SOURCE,\n        { mx: {} }\n      );\n      applyDescriptorFromValue(normalized, fallback);\n      return fallback;\n    })\n    .filter((value): value is Variable => Boolean(value));\n}\n\nexport function materializeGuardInputsWithMapping(\n  values: readonly unknown[],\n  options?: GuardInputOptions\n): GuardInputMappingEntry[] {\n  const nameHint = options?.nameHint ?? '__guard_input__';\n  const results: GuardInputMappingEntry[] = [];\n\n  for (let index = 0; index < values.length; index++) {\n    const value = values[index];\n    const variable = (() => {\n      if (isVariable(value)) {\n        return value;\n      }\n      const normalized = resolveNestedValue(value, { preserveProvenance: true });\n      const materialized = materializeExpressionValue(normalized, { name: nameHint });\n      if (materialized) {\n        return materialized;\n      }\n      const fallback = createSimpleTextVariable(\n        nameHint,\n        formatGuardInputValue(normalized),\n        FALLBACK_SOURCE,\n        { mx: {} }\n      );\n      applyDescriptorFromValue(normalized, fallback);\n      return fallback;\n    })();\n\n    if (variable) {\n      results.push({ index, variable });\n    }\n  }\n\n  return results;\n}\n\nfunction formatGuardInputValue(value: unknown): string {\n  if (value === null || value === undefined) {\n    return '';\n  }\n  if (typeof value === 'string') {\n    return value;\n  }\n  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {\n    return String(value);\n  }\n  if (typeof value === 'object') {\n    try {\n      return JSON.stringify(value);\n    } catch {\n      return '[object]';\n    }\n  }\n  return String(value);\n}\n\nfunction applyDescriptorFromValue(value: unknown, target: Variable): void {\n  const descriptor =\n    extractSecurityDescriptor(value, { recursive: true, mergeArrayElements: true }) ??\n    makeSecurityDescriptor();\n  if (!target.mx) {\n    target.mx = {};\n  }\n  updateVarMxFromDescriptor(target.mx, descriptor);\n  if ((target.mx as any).mxCache) {\n    delete (target.mx as any).mxCache;\n  }\n}\n","import type { DirectiveNode, ExecInvocation } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport type { Variable, VariableSource } from '@core/types/variable';\nimport { createSimpleTextVariable } from '@core/types/variable';\nimport { materializeExpressionValue } from '@core/types/provenance/ExpressionProvenance';\nimport { isVariable } from '../utils/variable-resolution';\n\ninterface ReplayEntry {\n  result: EvalResult;\n  guardVariable?: Variable;\n}\n\nconst INLINE_SOURCE: VariableSource = {\n  directive: 'var',\n  syntax: 'expression',\n  hasInterpolation: false,\n  isMultiLine: false\n};\n\nconst replayStore = new WeakMap<DirectiveNode, Map<ExecInvocation, ReplayEntry>>();\n\nfunction getReplayState(directive: DirectiveNode): Map<ExecInvocation, ReplayEntry> {\n  let state = replayStore.get(directive);\n  if (!state) {\n    state = new Map();\n    replayStore.set(directive, state);\n  }\n  return state;\n}\n\nasync function ensureReplayEntry(\n  directive: DirectiveNode,\n  env: Environment,\n  invocation: ExecInvocation\n): Promise<ReplayEntry> {\n  const state = getReplayState(directive);\n  const existing = state.get(invocation);\n  if (existing) {\n    return existing;\n  }\n  const { evaluateExecInvocation } = await import('./exec-invocation');\n  const result = await evaluateExecInvocation(invocation, env);\n  const entry: ReplayEntry = { result };\n  state.set(invocation, entry);\n  return entry;\n}\n\nfunction materializeGuardVariable(value: unknown): Variable | undefined {\n  if (isVariable(value)) {\n    return value;\n  }\n  const fromProvenance = materializeExpressionValue(value, { name: '__inline_exec__' });\n  if (fromProvenance) {\n    return fromProvenance;\n  }\n  if (value && typeof value === 'object') {\n    const metadataSecurity = (value as { metadata?: { security?: unknown } }).metadata?.security;\n    if (metadataSecurity) {\n      const textValue =\n        typeof (value as { text?: unknown }).text === 'string'\n          ? ((value as { text?: string }).text as string)\n          : typeof (value as { data?: unknown }).data === 'string'\n            ? ((value as { data?: string }).data as string)\n            : String((value as { data?: unknown }).data ?? value);\n      return createSimpleTextVariable('__inline_exec__', textValue, INLINE_SOURCE, {\n        security: metadataSecurity\n      });\n    }\n  }\n  return undefined;\n}\n\nexport async function replayInlineExecInvocations(\n  directive: DirectiveNode,\n  env: Environment,\n  invocations: readonly ExecInvocation[]\n): Promise<Variable[]> {\n  if (!invocations || invocations.length === 0) {\n    return [];\n  }\n\n  const guardVariables: Variable[] = [];\n  const unique = Array.from(new Set(invocations));\n  for (const invocation of unique) {\n    if (!invocation) {\n      continue;\n    }\n    const entry = await ensureReplayEntry(directive, env, invocation);\n    if (!entry.guardVariable) {\n      entry.guardVariable = materializeGuardVariable(entry.result.value);\n    }\n    if (entry.guardVariable) {\n      guardVariables.push(entry.guardVariable);\n    }\n  }\n\n  return guardVariables;\n}\n\nexport async function resolveDirectiveExecInvocation(\n  directive: DirectiveNode,\n  env: Environment,\n  invocation: ExecInvocation\n): Promise<EvalResult> {\n  const entry = await ensureReplayEntry(directive, env, invocation);\n  return entry.result;\n}\n\nexport function clearDirectiveReplay(directive: DirectiveNode): void {\n  replayStore.delete(directive);\n}\n","import type { DirectiveNode, ExecInvocation } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport {\n  createSimpleTextVariable,\n  type Variable,\n  type VariableSource,\n  type SecurityDescriptor\n} from '@core/types/variable';\nimport { VariableMetadataUtils } from '@core/types/variable/VariableMetadata';\nimport { interpolate } from '../core/interpreter';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { getTextContent } from '../utils/type-guard-helpers';\nimport { varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\nimport { materializeGuardInputs } from '../utils/guard-inputs';\nimport { replayInlineExecInvocations } from './directive-replay';\n\ntype AstValue = Record<string, unknown> & { type?: string };\n\n/**\n * Extract and evaluate directive inputs for hook consumption.\n * Implementation is incremental per directive; directives without\n * explicit handling currently return an empty array.\n */\nexport async function extractDirectiveInputs(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<readonly Variable[]> {\n  switch (directive.kind) {\n    case 'show':\n      return extractShowInputs(directive, env);\n    case 'output':\n      return extractOutputInputs(directive, env);\n    case 'append':\n      return extractOutputInputs(directive, env);\n    case 'run':\n      return extractRunInputs(directive, env);\n\n    default:\n      return [];\n  }\n}\n\nasync function extractShowInputs(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<readonly Variable[]> {\n  const inlineInvocations: ExecInvocation[] = [];\n  const invocation = directive.values?.invocation as ExecInvocation | undefined;\n  if (invocation?.type === 'ExecInvocation') {\n    inlineInvocations.push(invocation);\n  }\n  const execInvocation = directive.values?.execInvocation as ExecInvocation | undefined;\n  if (execInvocation?.type === 'ExecInvocation') {\n    inlineInvocations.push(execInvocation);\n  }\n\n  if (inlineInvocations.length > 0) {\n    const guardValues: Variable[] = [];\n    guardValues.push(\n      ...(await replayInlineExecInvocations(directive, env, inlineInvocations))\n    );\n    for (const inv of inlineInvocations) {\n      guardValues.push(...extractExecInvocationArgs(inv, env));\n    }\n    if (guardValues.length > 0) {\n      return materializeGuardInputs(guardValues);\n    }\n  }\n\n  const inputs: Variable[] = [];\n  const varName = resolveShowVariableName(directive);\n  if (!varName) {\n    return inputs;\n  }\n  const variable = env.getVariable(varName);\n  if (variable) {\n    inputs.push(variable);\n  }\n  return materializeGuardInputs(inputs);\n}\n\nfunction resolveShowVariableName(directive: DirectiveNode): string | undefined {\n  const invocation = directive.values?.invocation as any;\n  if (invocation) {\n    if (invocation.type === 'VariableReference') {\n      return invocation.identifier;\n    }\n    if (invocation.type === 'VariableReferenceWithTail') {\n      const innerVar = invocation.variable;\n      if (!innerVar) {\n        return undefined;\n      }\n      if (innerVar.type === 'TemplateVariable') {\n        return innerVar.identifier;\n      }\n      return innerVar.identifier;\n    }\n    if (invocation.type === 'TemplateVariable') {\n      return invocation.identifier;\n    }\n  }\n\n  const legacyVariable = directive.values?.variable as any;\n  if (!legacyVariable) {\n    return undefined;\n  }\n\n  const variableNode = Array.isArray(legacyVariable) ? legacyVariable[0] : legacyVariable;\n  if (!variableNode) {\n    return undefined;\n  }\n\n  if (variableNode.type === 'VariableReferenceWithTail') {\n    const innerVar = variableNode.variable;\n    if (innerVar?.type === 'TemplateVariable') {\n      return innerVar.identifier;\n    }\n    return innerVar?.identifier;\n  }\n\n  if (variableNode.type === 'VariableReference') {\n    return variableNode.identifier;\n  }\n\n  if (variableNode.type === 'TemplateVariable') {\n    return variableNode.identifier;\n  }\n\n  return undefined;\n}\n\nasync function extractOutputInputs(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<readonly Variable[]> {\n  const sourceNode: any = directive.values?.source;\n  if (!sourceNode) {\n    return [];\n  }\n\n  const execInvocation = findExecInvocation(sourceNode);\n  if (execInvocation) {\n    const guardValues = [\n      ...(await replayInlineExecInvocations(directive, env, [execInvocation])),\n      ...extractExecInvocationArgs(execInvocation, env)\n    ];\n    if (guardValues.length > 0) {\n      return materializeGuardInputs(guardValues);\n    }\n  }\n\n  const hasArgs =\n    Boolean(sourceNode.args && Array.isArray(sourceNode.args) && sourceNode.args.length > 0) ||\n    directive.subtype === 'outputInvocation' ||\n    directive.subtype === 'outputExecInvocation';\n\n  if (hasArgs) {\n    return [];\n  }\n\n  const varName = resolveOutputVariableName(sourceNode);\n  if (!varName) {\n    return [];\n  }\n\n  const variable = env.getVariable(varName);\n  if (!variable) {\n    return [];\n  }\n\n  return materializeGuardInputs([variable]);\n}\n\nfunction resolveOutputVariableName(sourceNode: any): string | undefined {\n  if (!sourceNode) {\n    return undefined;\n  }\n\n  if (Array.isArray(sourceNode)) {\n    const first = sourceNode[0];\n    if (first?.type === 'VariableReference') {\n      return first.identifier;\n    }\n    if (first?.type === 'TemplateVariable') {\n      return first.identifier;\n    }\n  }\n\n  if (sourceNode.identifier && Array.isArray(sourceNode.identifier)) {\n    const first = sourceNode.identifier[0];\n    if (first?.identifier) {\n      return first.identifier;\n    }\n  }\n\n  if (sourceNode.variable?.identifier) {\n    return sourceNode.variable.identifier;\n  }\n\n  if (typeof sourceNode.identifier === 'string') {\n    return sourceNode.identifier;\n  }\n\n  return undefined;\n}\n\nasync function extractRunInputs(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<readonly Variable[]> {\n  if (directive.subtype === 'runCommand') {\n    const commandNodes = directive.values?.identifier || directive.values?.command;\n    if (!commandNodes) {\n      return [];\n    }\n    const commandArray = Array.isArray(commandNodes) ? commandNodes : [commandNodes];\n    const interpolatedDescriptors: SecurityDescriptor[] = [];\n    const commandText = await interpolate(commandArray, env, InterpolationContext.ShellCommand, {\n      collectSecurityDescriptor: descriptor => {\n        if (descriptor) {\n          interpolatedDescriptors.push(descriptor);\n        }\n      }\n    });\n    const referencedVariables = collectVariablesFromNodes(commandArray, env);\n    const referencedDescriptors = referencedVariables\n      .map(variable => (variable.mx ? varMxToSecurityDescriptor(variable.mx) : undefined))\n      .filter((descriptor): descriptor is SecurityDescriptor => Boolean(descriptor));\n    const interpolationDescriptor =\n      interpolatedDescriptors.length === 1\n        ? interpolatedDescriptors[0]\n        : interpolatedDescriptors.length > 1\n          ? env.mergeSecurityDescriptors(...interpolatedDescriptors)\n          : undefined;\n    let mergedDescriptor =\n      referencedDescriptors.length > 0 ? env.mergeSecurityDescriptors(...referencedDescriptors) : undefined;\n    if (interpolationDescriptor) {\n      mergedDescriptor = mergedDescriptor\n        ? env.mergeSecurityDescriptors(mergedDescriptor, interpolationDescriptor)\n        : interpolationDescriptor;\n    }\n    const source: VariableSource = {\n      directive: 'run',\n      syntax: 'command',\n      hasInterpolation: true,\n      isMultiLine: Array.isArray(commandNodes) &&\n        commandNodes.some((node: any) => node?.type === 'Newline')\n    };\n    const variable = createSimpleTextVariable('__run_command__', commandText, source, {\n      mx: mergedDescriptor || {},\n      internal: { isSystem: true }\n    });\n    if (mergedDescriptor) {\n      env.recordSecurityDescriptor(mergedDescriptor);\n    }\n    return [variable];\n  }\n\n  if (\n    directive.subtype === 'runExec' ||\n    directive.subtype === 'runExecInvocation' ||\n    directive.subtype === 'runExecReference'\n  ) {\n    const execInvocation = (directive.values?.execInvocation ??\n      directive.values?.execRef) as ExecInvocation | undefined;\n    if (execInvocation?.type === 'ExecInvocation') {\n      const guardValues = [\n        ...(await replayInlineExecInvocations(directive, env, [execInvocation])),\n        ...extractExecInvocationArgs(execInvocation, env)\n      ];\n      if (guardValues.length > 0) {\n        return materializeGuardInputs(guardValues);\n      }\n    }\n    const execName = resolveRunExecName(directive);\n    if (!execName) {\n      return [];\n    }\n    const execVar = env.getVariable(execName);\n    return execVar ? materializeGuardInputs([execVar]) : [];\n  }\n\n  return [];\n}\n\nfunction resolveRunExecName(directive: DirectiveNode): string | undefined {\n  const identifierNodes = directive.values?.identifier;\n  if (identifierNodes && Array.isArray(identifierNodes) && identifierNodes[0]) {\n    const identifier = identifierNodes[0];\n    if (identifier && typeof identifier === 'object' && 'identifier' in identifier) {\n      return identifier.identifier as string;\n    }\n  }\n\n  const execInvocation = directive.values?.execInvocation;\n  if (execInvocation?.commandRef?.identifier) {\n    return execInvocation.commandRef.identifier;\n  }\n\n  const execRef = (directive.values as any)?.execRef;\n  if (execRef?.commandRef?.identifier) {\n    return execRef.commandRef.identifier;\n  }\n\n  return undefined;\n}\n\nfunction extractExecInvocationArgs(invocation: ExecInvocation, env: Environment): Variable[] {\n  const args = invocation.commandRef?.args ?? [];\n  return collectVariablesFromNodes(args, env);\n}\n\nfunction collectVariablesFromNodes(nodes: readonly unknown[], env: Environment): Variable[] {\n  const bucket = new Map<string, Variable>();\n  const seen = new WeakSet<object>();\n  for (const node of nodes) {\n    visitNodeForVariables(node as AstValue, env, bucket, seen);\n  }\n  return Array.from(bucket.values());\n}\n\nfunction findExecInvocation(candidate: unknown): ExecInvocation | undefined {\n  if (!candidate || typeof candidate !== 'object') {\n    return undefined;\n  }\n  const typed = candidate as AstValue;\n  if (typed.type === 'ExecInvocation') {\n    return typed as ExecInvocation;\n  }\n  for (const value of Object.values(typed)) {\n    if (Array.isArray(value)) {\n      for (const entry of value) {\n        const found = findExecInvocation(entry);\n        if (found) {\n          return found;\n        }\n      }\n      continue;\n    }\n    if (value && typeof value === 'object') {\n      const found = findExecInvocation(value);\n      if (found) {\n        return found;\n      }\n    }\n  }\n  return undefined;\n}\n\nfunction visitNodeForVariables(\n  node: AstValue | undefined,\n  env: Environment,\n  bucket: Map<string, Variable>,\n  seen: WeakSet<object>\n): void {\n  if (!node || typeof node !== 'object') {\n    return;\n  }\n  if (seen.has(node)) {\n    return;\n  }\n  seen.add(node);\n\n  switch (node.type) {\n    case 'VariableReference':\n      addVariableByIdentifier(node.identifier, env, bucket);\n      break;\n    case 'VariableReferenceWithTail':\n      visitNodeForVariables(node.variable as AstValue, env, bucket, seen);\n      break;\n    case 'TemplateVariable':\n      addVariableByIdentifier(node.identifier, env, bucket);\n      break;\n    case 'ExecInvocation': {\n      const commandRef = (node as { commandRef?: AstValue & { args?: unknown[]; objectReference?: AstValue } }).commandRef;\n      if (commandRef?.objectReference) {\n        visitNodeForVariables(commandRef.objectReference as AstValue, env, bucket, seen);\n      }\n      const execArgs = commandRef?.args ?? [];\n      for (const arg of execArgs) {\n        visitNodeForVariables(arg as AstValue, env, bucket, seen);\n      }\n      break;\n    }\n  }\n\n  for (const value of Object.values(node)) {\n    if (Array.isArray(value)) {\n      for (const entry of value) {\n        visitNodeForVariables(entry as AstValue, env, bucket, seen);\n      }\n      continue;\n    }\n    if (value && typeof value === 'object') {\n      visitNodeForVariables(value as AstValue, env, bucket, seen);\n    }\n  }\n}\n\nfunction addVariableByIdentifier(\n  identifier: unknown,\n  env: Environment,\n  bucket: Map<string, Variable>\n): void {\n  if (typeof identifier !== 'string' || bucket.has(identifier)) {\n    return;\n  }\n  const variable = env.getVariable(identifier);\n  if (!variable) {\n    return;\n  }\n  VariableMetadataUtils.attachContext(variable);\n  bucket.set(identifier, variable);\n}\n","import type { DirectiveNode, ExecInvocation } from './primitives';\nimport type { PipelineCommand } from './run';\nimport type { SourceLocation } from './index';\n\nexport type ExecInvocationNode = ExecInvocation;\n\nexport interface EffectHookNode extends PipelineCommand {\n  type: 'Effect';\n  location?: SourceLocation | null;\n}\n\nexport type HookableNode = DirectiveNode | ExecInvocationNode | EffectHookNode;\n\nexport function isDirectiveHookTarget(node: HookableNode): node is DirectiveNode {\n  return (node as DirectiveNode).kind !== undefined;\n}\n\nexport function isExecHookTarget(node: HookableNode): node is ExecInvocationNode {\n  return node.type === 'ExecInvocation';\n}\n\nexport function isEffectHookTarget(node: HookableNode): node is EffectHookNode {\n  return (node as EffectHookNode).type === 'Effect';\n}\n","import { GuardError } from '@core/errors/GuardError';\nimport type { HookDecision } from './HookManager';\nimport type { HookableNode } from '@core/types/hooks';\nimport { isDirectiveHookTarget } from '@core/types/hooks';\nimport type { GuardHint, GuardResult, GuardScope } from '@core/types/guard';\nimport type { Environment } from '../env/Environment';\nimport type {\n  OperationContext,\n  PipelineContextSnapshot,\n  GuardContextSnapshot\n} from '../env/ContextManager';\nimport type { Variable } from '@core/types/variable';\nimport { isVariable } from '../utils/variable-resolution';\nimport { GuardRetrySignal } from '@core/errors/GuardRetrySignal';\n\nconst DEFAULT_GUARD_MAX = 3;\nconst afterRetryDebugEnabled = process.env.DEBUG_AFTER_RETRY === '1';\n\ninterface GuardDecisionInfo {\n  guardName: string | null;\n  guardFilter?: string;\n  scope?: GuardScope;\n  inputPreview?: string | null;\n  retryHint?: string | null;\n  baseMessage: string;\n  guardContext?: GuardContextSnapshot;\n  guardInput?: Variable | readonly Variable[] | null | unknown;\n}\n\nexport async function handleGuardDecision(\n  decision: HookDecision,\n  node: HookableNode,\n  env: Environment,\n  operationContext: OperationContext\n): Promise<void> {\n  if (!decision || decision.action === 'continue') {\n    return;\n  }\n\n  const metadata = decision.metadata ?? {};\n  const guardName =\n    typeof metadata.guardName === 'string' || metadata.guardName === null\n      ? (metadata.guardName as string | null)\n      : null;\n  const reasonsArray = Array.isArray((metadata as any).reasons)\n    ? ((metadata as any).reasons as string[])\n    : undefined;\n  const guardResults = Array.isArray((metadata as any).guardResults)\n    ? ((metadata as any).guardResults as GuardResult[])\n    : undefined;\n  const hints = Array.isArray((metadata as any).hints)\n    ? ((metadata as any).hints as GuardHint[])\n    : undefined;\n  const guardContextSnapshot = buildGuardContextFromMetadata(\n    metadata as Record<string, unknown>,\n    reasonsArray,\n    guardResults,\n    hints\n  );\n  const primaryReason =\n    (typeof (metadata as any).reason === 'string'\n      ? (metadata as any).reason\n      : undefined) ?? (reasonsArray && reasonsArray.length > 0 ? reasonsArray[0] : undefined);\n  const info: GuardDecisionInfo = {\n    guardName,\n    guardFilter: typeof metadata.guardFilter === 'string' ? metadata.guardFilter : undefined,\n    scope: metadata.scope as GuardScope | undefined,\n    inputPreview:\n      typeof metadata.inputPreview === 'string' ? metadata.inputPreview : undefined,\n    retryHint: typeof metadata.hint === 'string' ? metadata.hint : undefined,\n    baseMessage:\n      primaryReason && primaryReason.length > 0\n        ? primaryReason\n        : decision.action === 'abort' || decision.action === 'deny'\n          ? 'Operation aborted by guard'\n          : 'Guard requested retry'\n    ,\n    guardContext: guardContextSnapshot,\n    guardInput: metadata.guardInput as Variable | readonly Variable[] | null | undefined\n  };\n\n  if (decision.action === 'abort' || decision.action === 'deny') {\n    throw new GuardError({\n      decision: 'deny',\n      guardName: info.guardName,\n      guardFilter: info.guardFilter,\n      scope: info.scope,\n      inputPreview: info.inputPreview ?? null,\n      retryHint: info.retryHint,\n      operation: operationContext,\n      reason: info.baseMessage,\n      guardContext: info.guardContext,\n      guardInput: info.guardInput ?? null,\n      reasons: reasonsArray,\n      guardResults,\n      hints,\n      sourceLocation: extractNodeLocation(node),\n      env\n    });\n  }\n\n  if (decision.action === 'retry') {\n    enforcePipelineGuardRetry(info, env, operationContext, node, {\n      reasons: reasonsArray,\n      guardResults,\n      hints\n    });\n  }\n}\n\nexport function getGuardTransformedInputs(\n  decision: HookDecision | undefined,\n  originalInputs?: readonly unknown[]\n): readonly Variable[] | undefined {\n  if (!decision?.metadata) {\n    return undefined;\n  }\n  const candidates = (decision.metadata as Record<string, unknown>).transformedInputs;\n  if (!Array.isArray(candidates)) {\n    return undefined;\n  }\n\n  const variables = candidates.filter(isVariable) as Variable[];\n  if (variables.length !== candidates.length) {\n    return undefined;\n  }\n\n  if (!originalInputs || originalInputs.length === 0) {\n    return variables;\n  }\n\n  return alignTransformedInputs(variables, originalInputs);\n}\n\nfunction enforcePipelineGuardRetry(\n  info: GuardDecisionInfo,\n  env: Environment,\n  operationContext: OperationContext,\n  node: HookableNode,\n  extras?: {\n    reasons?: string[];\n    guardResults?: GuardResult[];\n    hints?: GuardHint[];\n  }\n): never {\n  const pipelineContext = env.getPipelineContext();\n  if (!pipelineContext) {\n    throw new GuardError({\n      decision: 'deny',\n      guardName: info.guardName,\n      guardFilter: info.guardFilter,\n      scope: info.scope,\n      inputPreview: info.inputPreview ?? null,\n      retryHint: info.retryHint,\n      operation: operationContext,\n      guardContext: info.guardContext,\n      guardInput: info.guardInput ?? null,\n      reasons: extras?.reasons,\n      guardResults: extras?.guardResults,\n      hints: extras?.hints,\n      reason: 'guard retry requires pipeline context (non-pipeline retry deferred to Phase 7.3)',\n      sourceLocation: extractNodeLocation(node),\n      env\n    });\n  }\n\n  if (!canRetryWithinPipeline(pipelineContext)) {\n    if (afterRetryDebugEnabled) {\n      try {\n        console.error('[after-guard-retry] pipeline retry denied (non-retryable source)', {\n          guardName: info.guardName,\n          guardFilter: info.guardFilter,\n          operation: {\n            type: operationContext.type,\n            subtype: operationContext.subtype,\n            name: operationContext.name\n          },\n          retryHint: info.retryHint\n        });\n      } catch {\n        // ignore debug failures\n      }\n    }\n    throw new GuardError({\n      decision: 'deny',\n      guardName: info.guardName,\n      guardFilter: info.guardFilter,\n      scope: info.scope,\n      inputPreview: info.inputPreview ?? null,\n      retryHint: info.retryHint,\n      operation: operationContext,\n      guardContext: info.guardContext,\n      guardInput: info.guardInput ?? null,\n      reasons: extras?.reasons,\n      guardResults: extras?.guardResults,\n      hints: extras?.hints,\n      reason: `Cannot retry: ${info.retryHint ?? 'guard requested retry'} (source not retryable)`,\n      sourceLocation: extractNodeLocation(node),\n      env\n    });\n  }\n\n  throw new GuardRetrySignal({\n    decision: 'retry',\n    guardName: info.guardName,\n    guardFilter: info.guardFilter,\n    scope: info.scope,\n    inputPreview: info.inputPreview ?? null,\n    retryHint: info.retryHint,\n    operation: operationContext,\n    guardContext: info.guardContext,\n    guardInput: info.guardInput ?? null,\n    reasons: extras?.reasons,\n    guardResults: extras?.guardResults,\n    hints: extras?.hints,\n    reason: info.baseMessage,\n    sourceLocation: extractNodeLocation(node),\n    env\n  });\n}\n\nfunction canRetryWithinPipeline(context: PipelineContextSnapshot): boolean {\n  if (!context.sourceRetryable) {\n    return false;\n  }\n  return true;\n}\n\nfunction buildGuardContextFromMetadata(\n  metadata: Record<string, unknown>,\n  reasons?: string[],\n  guardResults?: GuardResult[],\n  hints?: GuardHint[]\n): GuardContextSnapshot {\n  const baseContext = (metadata.guardContext as GuardContextSnapshot | undefined) ?? {};\n  const trace =\n    guardResults ?? (Array.isArray((baseContext as any).trace) ? (baseContext as any).trace : []);\n  const hintList =\n    hints ?? (Array.isArray((baseContext as any).hints) ? (baseContext as any).hints : []);\n  const reasonList =\n    reasons ??\n    (Array.isArray((baseContext as any).reasons) ? ((baseContext as any).reasons as string[]) : []);\n  const attempt =\n    typeof baseContext.attempt === 'number'\n      ? baseContext.attempt\n      : typeof baseContext.try === 'number'\n        ? baseContext.try ?? 0\n        : 0;\n  const max = typeof baseContext.max === 'number' ? baseContext.max : DEFAULT_GUARD_MAX;\n  const resolvedReason =\n    baseContext.reason ??\n    (typeof metadata.reason === 'string' ? metadata.reason : undefined) ??\n    reasonList[0] ??\n    null;\n\n  return {\n    ...baseContext,\n    trace,\n    hints: hintList,\n    reasons: reasonList,\n    reason: resolvedReason,\n    attempt,\n    try: typeof baseContext.try === 'number' ? baseContext.try : attempt,\n    max\n  };\n}\n\nfunction extractNodeLocation(node: HookableNode) {\n  if (isDirectiveHookTarget(node)) {\n    return node.location ?? null;\n  }\n  return node.location ?? null;\n}\n\nfunction alignTransformedInputs(\n  transformed: readonly Variable[],\n  originals: readonly unknown[]\n): Variable[] {\n  const aligned: Variable[] = [];\n  const limit = Math.min(transformed.length, originals.length);\n  for (let i = 0; i < limit; i++) {\n    const replacement = transformed[i];\n    const original = originals[i];\n    if (isVariable(original) && original.name !== replacement.name) {\n      const cloned: Variable = {\n        ...replacement,\n        name: original.name,\n        mx: replacement.mx ? { ...replacement.mx } : undefined,\n        internal: replacement.internal ? { ...replacement.internal } : undefined\n      };\n      if (cloned.mx?.mxCache) {\n        delete cloned.mx.mxCache;\n      }\n      aligned.push(cloned);\n    } else {\n      aligned.push(replacement);\n    }\n  }\n\n  for (let i = limit; i < transformed.length; i++) {\n    aligned.push(transformed[i]);\n  }\n\n  return aligned;\n}\n","import type { DirectiveNode, TextNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport { interpolate } from '../core/interpreter';\nimport { astLocationToSourceLocation } from '@core/types';\nimport { createPathVariable, type VariableSource } from '@core/types/variable';\nimport type { SecurityDescriptor } from '@core/types/security';\n\n/**\n * Evaluate @path directives.\n * Resolves paths with special variables like @PROJECTPATH.\n * \n * Ported from PathDirectiveHandler.\n */\nexport async function evaluatePath(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  // Extract identifier - this is a variable name, not content to interpolate\n  const identifierNodes = directive.values?.identifier;\n  if (!identifierNodes || !Array.isArray(identifierNodes) || identifierNodes.length === 0) {\n    throw new Error('Path directive missing identifier');\n  }\n  \n  // For path directives, extract the variable name\n  const identifierNode = identifierNodes[0];\n  let identifier: string;\n  \n  if (identifierNode.type === 'Text' && 'content' in identifierNode) {\n    // eslint-disable-next-line mlld/no-ast-string-manipulation\n    identifier = (identifierNode as TextNode).content;\n  } else if (identifierNode.type === 'VariableReference' && 'identifier' in identifierNode) {\n    identifier = (identifierNode as any).identifier as string;\n  } else {\n    throw new Error('Path directive identifier must be a simple variable name');\n  }\n  \n  // Extract path nodes\n  const pathNodes = directive.values?.path;\n  if (!pathNodes) {\n    throw new Error('Path directive missing path');\n  }\n  \n  // Check if this is a URL path based on the path node structure\n  const pathNode = pathNodes[0]; // Assuming single path node\n  const isURL = pathNode?.subtype === 'urlPath' || pathNode?.subtype === 'urlSectionPath';\n  \n  // Interpolate the path (resolve variables)\n  const descriptors: SecurityDescriptor[] = [];\n  const interpolatedPath = await interpolate(pathNodes, env, undefined, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  const merged =\n    descriptors.length === 1\n      ? descriptors[0]\n      : descriptors.length > 1\n        ? env.mergeSecurityDescriptors(...descriptors)\n        : undefined;\n  if (merged) {\n    env.recordSecurityDescriptor(merged);\n  }\n  \n  // Handle special path variables and absolute paths\n  let resolvedPath = interpolatedPath;\n  \n  // Check if this is a resolver reference first\n  const resolverManager = env.getResolverManager();\n  if (resolverManager && interpolatedPath.startsWith('@')) {\n    // Extract potential resolver name from the path\n    const pathParts = interpolatedPath.substring(1).split('/');\n    const potentialResolver = pathParts[0];\n    \n    if (resolverManager.isResolverName(potentialResolver)) {\n      // This is a resolver reference - try to resolve it\n      try {\n        const resolverContent = await env.resolveModule(interpolatedPath, 'path');\n        \n        // Validate content type for paths - reject modules\n        if (resolverContent.contentType === 'module') {\n          throw new Error(\n            `Cannot use module as path: ${interpolatedPath} (modules must be imported, not used as paths)`\n          );\n        }\n        \n        // For text/data content, use the content as the path value\n        resolvedPath = resolverContent.content;\n      } catch (error) {\n        // If it's a module content type error, re-throw it\n        if (error.message?.includes('Cannot use module as path')) {\n          throw error;\n        }\n        // For other errors, fall back to normal path resolution\n        resolvedPath = await env.resolvePath(interpolatedPath);\n      }\n    } else {\n      // Not a resolver, use normal path resolution\n      resolvedPath = await env.resolvePath(interpolatedPath);\n    }\n  } else if (isURL || env.isURL(interpolatedPath)) {\n    // URLs remain as-is\n    resolvedPath = interpolatedPath;\n  } else {\n    // Only resolve special variables and absolute paths for file paths\n    if (interpolatedPath.startsWith('@PROJECTPATH') ||\n        interpolatedPath.startsWith('/')) {\n      resolvedPath = await env.resolvePath(interpolatedPath);\n    }\n    // Normalize the path (remove ./ prefix if present)\n    resolvedPath = resolvedPath.replace(/^\\.\\//, '');\n  }\n  \n  // Create variable source metadata\n  const source: VariableSource = {\n    directive: 'var', // Path directives create variables in the new system\n    syntax: 'path',\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n  \n  // Create and store the variable\n  const location = astLocationToSourceLocation(directive.location, env.getCurrentFilePath());\n  const variable = createPathVariable(\n    identifier,\n    resolvedPath,\n    interpolatedPath, // Original path before resolution\n    isURL || env.isURL(resolvedPath),\n    resolvedPath.startsWith('/'), // Is absolute\n    source,\n    { definedAt: location }\n  );\n  \n  env.setVariable(identifier, variable);\n  \n  // Return the resolved path\n  return { value: resolvedPath, env };\n}\n","import type { DataLabel, ImportType } from '@core/types/security';\nimport { labelsForPath } from './paths';\n\ntype ImmutableArray<T> = readonly T[];\n\nfunction dedupe<T>(values: Iterable<T>): T[] {\n  const seen = new Set<T>();\n  for (const value of values) {\n    if (!seen.has(value)) {\n      seen.add(value);\n    }\n  }\n  return Array.from(seen);\n}\n\nfunction freezeArray<T>(values: Iterable<T> | undefined): ImmutableArray<T> {\n  const array = values ? dedupe(values) : [];\n  return Object.freeze(array.slice()) as ImmutableArray<T>;\n}\n\nexport interface TaintSnapshot {\n  readonly sources: ImmutableArray<string>;\n  readonly taint: ImmutableArray<DataLabel>;\n  readonly labels: ImmutableArray<DataLabel>;\n}\n\nexport interface TrackTaintOptions {\n  sources?: Iterable<string>;\n  labels?: Iterable<DataLabel>;\n  taint?: Iterable<DataLabel>;\n}\n\nexport class TaintTracker {\n  private readonly entries = new Map<string, TaintSnapshot>();\n\n  track(id: string, options?: TrackTaintOptions): TaintSnapshot {\n    const existing = this.entries.get(id);\n    const mergedSources = freezeArray<string>([\n      ...(existing?.sources ?? []),\n      ...(options?.sources ?? [])\n    ]);\n\n    const mergedLabels = freezeArray<DataLabel>([\n      ...(existing?.labels ?? []),\n      ...(options?.labels ?? [])\n    ]);\n\n    const mergedTaint = freezeArray<DataLabel>([\n      ...(existing?.taint ?? []),\n      ...mergedLabels,\n      ...(options?.taint ?? [])\n    ]);\n\n    const snapshot: TaintSnapshot = Object.freeze({\n      sources: mergedSources,\n      labels: mergedLabels,\n      taint: mergedTaint\n    });\n\n    this.entries.set(id, snapshot);\n    return snapshot;\n  }\n\n  get(id: string): TaintSnapshot | undefined {\n    return this.entries.get(id);\n  }\n\n  merge(id: string, ...snapshots: Array<TaintSnapshot | undefined>): TaintSnapshot {\n    const incoming = snapshots.filter(\n      (snapshot): snapshot is TaintSnapshot => Boolean(snapshot)\n    );\n\n    const existing = this.entries.get(id);\n    if (!existing && incoming.length === 0) {\n      const defaultSnapshot = Object.freeze({\n        sources: Object.freeze([]) as ImmutableArray<string>,\n        labels: Object.freeze([]) as ImmutableArray<DataLabel>,\n        taint: Object.freeze([]) as ImmutableArray<DataLabel>\n      });\n      this.entries.set(id, defaultSnapshot);\n      return defaultSnapshot;\n    }\n\n    const sources = freezeArray<string>([\n      ...(existing?.sources ?? []),\n      ...incoming.flatMap(snapshot => snapshot.sources)\n    ]);\n\n    const labels = freezeArray<DataLabel>([\n      ...(existing?.labels ?? []),\n      ...incoming.flatMap(snapshot => snapshot.labels)\n    ]);\n\n    const taint = freezeArray<DataLabel>([\n      ...(existing?.taint ?? []),\n      ...incoming.flatMap(snapshot => snapshot.taint),\n      ...labels\n    ]);\n\n    const snapshot: TaintSnapshot = Object.freeze({\n      sources,\n      labels,\n      taint\n    });\n\n    this.entries.set(id, snapshot);\n    return snapshot;\n  }\n\n  clear(): void {\n    this.entries.clear();\n  }\n}\n\nexport interface ImportTaintOptions {\n  importType: ImportType;\n  resolverName?: string;\n  source?: string;\n  labels?: readonly DataLabel[];  // From resolver mx\n  resolvedPath?: string;\n  sourceType?: 'file' | 'url' | 'module' | 'resolver' | 'input';\n}\n\nfunction isUrlLike(value: string): boolean {\n  return /^https?:\\/\\//i.test(value);\n}\n\nfunction shouldTreatAsFile(options: ImportTaintOptions, resolvedPath?: string): boolean {\n  if (!resolvedPath) {\n    return false;\n  }\n  if (options.sourceType === 'url' || options.importType === 'cached') {\n    return false;\n  }\n  if (options.sourceType === 'module' || options.sourceType === 'input') {\n    return false;\n  }\n  if (isUrlLike(resolvedPath)) {\n    return false;\n  }\n  if (resolvedPath.startsWith('@')) {\n    return false;\n  }\n  return true;\n}\n\nexport function deriveImportTaint(options: ImportTaintOptions): TaintSnapshot {\n  const resolverName = options.resolverName?.toLowerCase();\n  const resolvedPath = options.resolvedPath ?? options.source;\n  const dirLabels =\n    resolvedPath && shouldTreatAsFile(options, resolvedPath)\n      ? labelsForPath(resolvedPath)\n      : [];\n\n  const sources = freezeArray<string>([\n    ...(resolverName === 'dynamic' ? ['dynamic-module'] : []),\n    ...(options.source ? [options.source] : resolverName ? [`resolver:${resolverName}`] : [])\n  ]);\n\n  const explicitLabels = freezeArray(options.labels);\n  const taint = freezeArray<DataLabel>([\n    ...explicitLabels,\n    ...(resolverName === 'dynamic' ? ['src:dynamic'] : []),\n    ...(dirLabels.length > 0 ? ['src:file', ...dirLabels] : [])\n  ]);\n\n  return Object.freeze({\n    sources,\n    labels: explicitLabels,\n    taint\n  });\n}\n\nexport interface CommandTaintOptions {\n  command: string;\n  source?: string;\n}\n\nexport function deriveCommandTaint(options: CommandTaintOptions): TaintSnapshot {\n  const baseCommand = options.command.trim().split(/\\s+/)[0] ?? '';\n  const sources = freezeArray<string>([\n    options.source ? options.source : `command:${baseCommand}`\n  ]);\n  const taint = freezeArray<DataLabel>(['src:exec']);\n\n  return Object.freeze({\n    sources,\n    labels: Object.freeze([]) as ImmutableArray<DataLabel>,\n    taint\n  });\n}\n\nexport function mergeTaintSnapshots(\n  ...snapshots: Array<TaintSnapshot | undefined>\n): TaintSnapshot | undefined {\n  const defined = snapshots.filter(\n    (snapshot): snapshot is TaintSnapshot => Boolean(snapshot)\n  );\n  if (defined.length === 0) {\n    return undefined;\n  }\n\n  const sources = freezeArray<string>(\n    defined.flatMap(snapshot => snapshot.sources)\n  );\n  const labels = freezeArray<DataLabel>(defined.flatMap(snapshot => snapshot.labels));\n  const taint = freezeArray<DataLabel>(\n    defined.flatMap(snapshot => snapshot.taint).concat(labels)\n  );\n\n  return Object.freeze({\n    sources,\n    labels,\n    taint\n  });\n}\n","/**\n * Streaming Adapter Registry\n *\n * Central registry for streaming format adapters.\n * Provides lazy-loading of builtin adapters and registration of custom adapters.\n */\n\nimport type { StreamAdapter, AdapterConfig } from './adapters/base';\nimport { createNDJSONAdapter } from './adapters/ndjson';\n\nexport type BuiltinAdapterName =\n  | 'claude-code'\n  | 'anthropic'\n  | 'ndjson'\n  | 'claude-agent-sdk'\n  | '@mlld/claude-agent-sdk';\n\nexport interface AdapterRegistryEntry {\n  name: string;\n  version: string;\n  description?: string;\n  factory: () => StreamAdapter;\n}\n\n/**\n * Builtin adapter definitions with lazy loading.\n */\nconst BUILTIN_ADAPTERS: Record<BuiltinAdapterName, () => Promise<StreamAdapter>> = {\n  'claude-code': async () => {\n    const { createClaudeCodeAdapter } = await import('./adapters/claude-code');\n    return createClaudeCodeAdapter();\n  },\n  'claude-agent-sdk': async () => {\n    const { createClaudeCodeAdapter } = await import('./adapters/claude-code');\n    return createClaudeCodeAdapter();\n  },\n  '@mlld/claude-agent-sdk': async () => {\n    const { createClaudeCodeAdapter } = await import('./adapters/claude-code');\n    return createClaudeCodeAdapter();\n  },\n  'anthropic': async () => {\n    // Anthropic API uses the same format as Claude Code for now\n    const { createClaudeCodeAdapter } = await import('./adapters/claude-code');\n    return createClaudeCodeAdapter();\n  },\n  'ndjson': async () => {\n    // Generic NDJSON adapter with minimal schema\n    return createNDJSONAdapter({\n      name: 'generic-ndjson',\n      schemas: [{\n        kind: 'message',\n        matchPath: 'type',\n        matchValue: 'text',\n        extract: { chunk: ['text', 'content', 'message', 'data'] }\n      }]\n    });\n  }\n};\n\n/**\n * Adapter Registry\n *\n * Manages streaming format adapters with support for:\n * - Builtin adapters (lazy-loaded)\n * - Custom adapter registration\n * - Adapter lookup by name\n */\nexport class AdapterRegistry {\n  private customAdapters: Map<string, AdapterRegistryEntry> = new Map();\n  private adapterCache: Map<string, StreamAdapter> = new Map();\n\n  /**\n   * Register a custom adapter.\n   */\n  register(name: string, entry: Omit<AdapterRegistryEntry, 'name'>): void {\n    this.customAdapters.set(name, { name, ...entry });\n    // Clear cache to force fresh creation\n    this.adapterCache.delete(name);\n  }\n\n  /**\n   * Register an adapter from a configuration object.\n   */\n  registerConfig(config: AdapterConfig): void {\n    this.register(config.name, {\n      version: '1.0.0',\n      description: `Custom adapter: ${config.name}`,\n      factory: () => createNDJSONAdapter(config)\n    });\n  }\n\n  /**\n   * Get an adapter by name.\n   * Returns a cached instance if available.\n   */\n  async get(name: string): Promise<StreamAdapter | undefined> {\n    // Check cache first\n    if (this.adapterCache.has(name)) {\n      return this.adapterCache.get(name);\n    }\n\n    // Check custom adapters\n    if (this.customAdapters.has(name)) {\n      const entry = this.customAdapters.get(name)!;\n      const adapter = entry.factory();\n      this.adapterCache.set(name, adapter);\n      return adapter;\n    }\n\n    // Check builtin adapters\n    if (name in BUILTIN_ADAPTERS) {\n      const factory = BUILTIN_ADAPTERS[name as BuiltinAdapterName];\n      const adapter = await factory();\n      this.adapterCache.set(name, adapter);\n      return adapter;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Get a builtin adapter by name (synchronous).\n   * Only works if the adapter has been loaded previously.\n   */\n  getCached(name: string): StreamAdapter | undefined {\n    return this.adapterCache.get(name);\n  }\n\n  /**\n   * Check if an adapter exists (builtin or custom).\n   */\n  has(name: string): boolean {\n    return this.customAdapters.has(name) || name in BUILTIN_ADAPTERS;\n  }\n\n  /**\n   * Get list of all available adapter names.\n   */\n  list(): string[] {\n    const builtins = Object.keys(BUILTIN_ADAPTERS);\n    const custom = Array.from(this.customAdapters.keys());\n    return [...new Set([...builtins, ...custom])];\n  }\n\n  /**\n   * Get information about an adapter.\n   */\n  getInfo(name: string): AdapterRegistryEntry | undefined {\n    if (this.customAdapters.has(name)) {\n      return this.customAdapters.get(name);\n    }\n\n    if (name in BUILTIN_ADAPTERS) {\n      return {\n        name,\n        version: '1.0.0',\n        description: `Builtin adapter for ${name} streaming format`,\n        factory: () => { throw new Error('Use get() for builtin adapters'); }\n      };\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Clear the adapter cache.\n   */\n  clearCache(): void {\n    this.adapterCache.clear();\n  }\n\n  /**\n   * Unregister a custom adapter.\n   */\n  unregister(name: string): boolean {\n    this.adapterCache.delete(name);\n    return this.customAdapters.delete(name);\n  }\n}\n\n/**\n * Global adapter registry instance.\n */\nexport const adapterRegistry = new AdapterRegistry();\n\n/**\n * Get an adapter by name from the global registry.\n */\nexport async function getAdapter(name: string): Promise<StreamAdapter | undefined> {\n  return adapterRegistry.get(name);\n}\n\n/**\n * Register a custom adapter in the global registry.\n */\nexport function registerAdapter(name: string, entry: Omit<AdapterRegistryEntry, 'name'>): void {\n  adapterRegistry.register(name, entry);\n}\n\n/**\n * Check if an adapter exists in the global registry.\n */\nexport function hasAdapter(name: string): boolean {\n  return adapterRegistry.has(name);\n}\n","import type { Environment } from '@interpreter/env/Environment';\nimport type { AdapterConfig, StreamAdapter } from './adapters/base';\nimport { createNDJSONAdapter } from './adapters/ndjson';\nimport { getAdapter } from './adapter-registry';\n\nfunction isStreamAdapter(value: unknown): value is StreamAdapter {\n  return Boolean(\n    value &&\n    typeof value === 'object' &&\n    typeof (value as StreamAdapter).processChunk === 'function' &&\n    typeof (value as StreamAdapter).flush === 'function'\n  );\n}\n\nfunction isAdapterConfig(value: unknown): value is AdapterConfig {\n  return Boolean(\n    value &&\n    typeof value === 'object' &&\n    Array.isArray((value as AdapterConfig).schemas)\n  );\n}\n\n/**\n * Resolve a streamFormat value from a withClause.\n * Accepts literal objects, VariableReferences, or expressions.\n */\nexport async function resolveStreamFormatValue(\n  source: unknown,\n  env: Environment\n): Promise<unknown> {\n  if (source === undefined || source === null) {\n    return source;\n  }\n\n  let value: unknown = source;\n\n  // Evaluate expression nodes (VariableReference, expressions, etc.)\n  if (\n    typeof value === 'object' &&\n    value !== null &&\n    ((value as any).type || Array.isArray(value))\n  ) {\n    const { evaluate } = await import('@interpreter/core/interpreter');\n    const result = await evaluate(value as any, env, { isExpression: true });\n    value = result.value;\n  }\n\n  // Unwrap Variables to raw values\n  const { isVariable, resolveValue, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n  if (isVariable(value)) {\n    value = await resolveValue(value, env, ResolutionContext.Display);\n  }\n\n  return value;\n}\n\n/**\n * Create a StreamAdapter from a string name or config object.\n * Returns undefined when the value cannot be converted.\n */\nexport async function loadStreamAdapter(\n  value: unknown\n): Promise<StreamAdapter | undefined> {\n  if (!value) {\n    return undefined;\n  }\n\n  if (typeof value === 'string') {\n    return getAdapter(value);\n  }\n\n  if (isStreamAdapter(value)) {\n    return value;\n  }\n\n  if (isAdapterConfig(value)) {\n    const config: AdapterConfig = {\n      name: typeof value.name === 'string' ? value.name : 'custom-stream-adapter',\n      format: 'ndjson',\n      schemas: value.schemas,\n      defaultSchema: value.defaultSchema\n    };\n    return createNDJSONAdapter(config);\n  }\n\n  return undefined;\n}\n","import { ensureStructuredValue, isStructuredValue, type StructuredValue } from './structured-value';\n\n/**\n * Feature flag for structured exec behaviour.\n * When disabled, legacy string behaviour is preserved.\n */\nexport function isStructuredExecEnabled(): boolean {\n  return true;\n}\n\n/**\n * Wrap exec results when the feature flag is enabled.\n * When disabled, returns the legacy string representation.\n */\nexport function wrapExecResult<T>(value: T, options?: { type?: string; text?: string }): StructuredValue<T> {\n  if (isStructuredValue(value)) {\n    if (options?.type || options?.text) {\n      return ensureStructuredValue(value, options?.type as any, options?.text);\n    }\n    return value;\n  }\n\n  return ensureStructuredValue(value, options?.type as any, options?.text);\n}\n\nexport function wrapPipelineResult<T>(value: T, options?: { type?: string; text?: string }): StructuredValue<T> {\n  return wrapExecResult(value, options);\n}\n","import { asText, asData, isStructuredValue, type StructuredValue } from './structured-value';\nimport { JSONFormatter } from '../core/json-formatter';\nimport {\n  isLoadContentResult\n} from '@core/types/load-content';\n\ntype SimpleClassification = { kind: 'simple'; text: string };\ntype ArrayClassification = { kind: 'array-simple'; elements: string[] };\ntype ComplexClassification = { kind: 'complex'; text: string };\n\nexport type ShellValueClassification =\n  | SimpleClassification\n  | ArrayClassification\n  | ComplexClassification;\n\n/**\n * Classify arbitrary values for shell interpolation.\n * Simple values can be interpolated directly.\n * Array-simple values expand into multiple arguments or stdin lines.\n * Complex values must be passed as a single escaped payload.\n */\nexport function classifyShellValue(value: unknown): ShellValueClassification {\n  if (value === undefined) {\n    return { kind: 'simple', text: '' };\n  }\n\n  if (value === null) {\n    return { kind: 'simple', text: 'null' };\n  }\n\n  if (typeof value === 'string') {\n    if (looksLikeStructuredString(value)) {\n      return { kind: 'complex', text: value };\n    }\n    return { kind: 'simple', text: value };\n  }\n\n  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {\n    return { kind: 'simple', text: String(value) };\n  }\n\n  if (Buffer.isBuffer(value)) {\n    return { kind: 'simple', text: value.toString('utf8') };\n  }\n\n  if (isStructuredValue(value)) {\n    return classifyStructuredValue(value);\n  }\n\n  if (isLoadContentResult(value)) {\n    return { kind: 'complex', text: asText(value) };\n  }\n\n  if (isStructuredValue(value) && value.type === 'array') {\n    // Check if this is a renamed-content array (array-simple) or load-content-result array (complex)\n    const arrayType = value.mx?.arrayType;\n    if (arrayType === 'renamed-content') {\n      const data = value.data as any[];\n      const elements = data.map(item => String(item ?? ''));\n      return { kind: 'array-simple', elements };\n    }\n    // load-content-result arrays are complex\n    return { kind: 'complex', text: value.text };\n  }\n\n  if (Array.isArray(value)) {\n    return classifyArray(value);\n  }\n\n  if (typeof value === 'object') {\n    return {\n      kind: 'complex',\n      text: JSONFormatter.stringify(normalizeForJson(value))\n    };\n  }\n\n  return { kind: 'simple', text: String(value) };\n}\n\n/**\n * Convert a value into stdin-safe text using shell classification.\n */\nexport function coerceValueForStdin(value: unknown): string {\n  const classification = classifyShellValue(value);\n  if (classification.kind === 'simple') {\n    return classification.text;\n  }\n  if (classification.kind === 'array-simple') {\n    return classification.elements.join('\\n');\n  }\n  return classification.text;\n}\n\nfunction classifyStructuredValue(value: StructuredValue): ShellValueClassification {\n  const data = value.data;\n\n  if (Array.isArray(data)) {\n    return classifyArray(data);\n  }\n\n  if (data && typeof data === 'object') {\n    return {\n      kind: 'complex',\n      text: JSONFormatter.stringify(normalizeForJson(data))\n    };\n  }\n\n  return { kind: 'simple', text: asText(value) };\n}\n\nfunction classifyArray(array: unknown[]): ShellValueClassification {\n  if (array.length === 0) {\n    return { kind: 'array-simple', elements: [] };\n  }\n\n  const elements: string[] = [];\n  for (const item of array) {\n    const classification = classifyShellValue(item);\n    if (classification.kind === 'simple') {\n      elements.push(classification.text);\n      continue;\n    }\n    return {\n      kind: 'complex',\n      text: JSONFormatter.stringify(normalizeForJson(array))\n    };\n  }\n\n  return { kind: 'array-simple', elements };\n}\n\nfunction normalizeForJson(value: unknown): unknown {\n  if (isStructuredValue(value)) {\n    return normalizeForJson(asData(value));\n  }\n\n  if (isLoadContentResult(value)) {\n    try {\n      if (value.json !== undefined) {\n        return value.json;\n      }\n    } catch {\n      // Ignore json getter errors and fall back to content parsing\n    }\n    try {\n      return JSON.parse(asText(value));\n    } catch {\n      return asText(value);\n    }\n  }\n\n  if (isStructuredValue(value) && value.type === 'array') {\n    const data = value.data as any[];\n    return data.map(item => normalizeForJson(item));\n  }\n\n  if (Array.isArray(value)) {\n    return value.map(item => normalizeForJson(item));\n  }\n\n  if (typeof value === 'bigint') {\n    return value.toString();\n  }\n\n  if (value && typeof value === 'object') {\n    const entries = Object.entries(value as Record<string, unknown>).map(([key, val]) => [\n      key,\n      normalizeForJson(val)\n    ]);\n    return Object.fromEntries(entries);\n  }\n\n  return value;\n}\n\nfunction looksLikeStructuredString(value: string): boolean {\n  const trimmed = value.trim();\n  if (trimmed.length < 2) {\n    return false;\n  }\n\n  const first = trimmed[0];\n  const last = trimmed[trimmed.length - 1];\n  if (!((first === '[' && last === ']') || (first === '{' && last === '}'))) {\n    return false;\n  }\n\n  // Require at least one structural character between the delimiters\n  // NOTE: This is a heuristic quick check. We still rely on JSON5/JSON parsing later;\n  // the goal here is to avoid eagerly stringifying obviously structured payloads.\n  const inner = trimmed.slice(1, -1);\n  return /[{}\\[\\]:,]/.test(inner);\n}\n","import path from 'path';\nimport type { ContentNodeArray, SourceLocation } from '@core/types';\nimport { interpolate } from '../core/interpreter';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { MlldError, ErrorSeverity } from '@core/errors';\nimport type { Environment } from '../env/Environment';\n\nexport interface WorkingDirectoryOptions {\n  sourceLocation?: SourceLocation;\n  directiveType?: string;\n}\n\nfunction createWorkingDirError(\n  message: string,\n  workingDirectory: string,\n  env: Environment,\n  options: WorkingDirectoryOptions\n): MlldError {\n  return new MlldError(message, {\n    code: 'INVALID_WORKING_DIRECTORY',\n    severity: ErrorSeverity.Recoverable,\n    sourceLocation: options.sourceLocation,\n    env,\n    details: {\n      workingDirectory,\n      directiveType: options.directiveType\n    }\n  });\n}\n\nexport async function resolveWorkingDirectory(\n  workingDir: ContentNodeArray | string | undefined,\n  env: Environment,\n  options: WorkingDirectoryOptions = {}\n): Promise<string | undefined> {\n  if (!workingDir || (Array.isArray(workingDir) && workingDir.length === 0)) {\n    return undefined;\n  }\n\n  const rawPath =\n    typeof workingDir === 'string'\n      ? workingDir\n      : await interpolate(workingDir, env, InterpolationContext.FilePath);\n\n  const candidate = rawPath.trim();\n\n  // Empty string or \".\" means \"use current working directory\"\n  // This allows reusable functions where dir is optional\n  if (!candidate || candidate === '.') {\n    return undefined;\n  }\n\n  if (candidate.startsWith('~')) {\n    throw createWorkingDirError('Working directory cannot use \"~\" expansion.', candidate, env, options);\n  }\n\n  if (/^[a-zA-Z]:[\\\\/]/.test(candidate) || candidate.startsWith('\\\\\\\\')) {\n    throw createWorkingDirError('Working directory must use absolute Unix-style paths.', candidate, env, options);\n  }\n\n  if (!path.posix.isAbsolute(candidate)) {\n    throw createWorkingDirError('Working directory must start with \"/\".', candidate, env, options);\n  }\n\n  const normalized = path.posix.normalize(candidate);\n  const fs = env.getFileSystemService();\n\n  if (!(await fs.exists(normalized))) {\n    throw createWorkingDirError('Working directory does not exist.', normalized, env, options);\n  }\n\n  const isDirectory = await fs.isDirectory(normalized);\n  if (!isDirectory) {\n    throw createWorkingDirError('Working directory must be a directory.', normalized, env, options);\n  }\n\n  return normalized;\n}\n","import type { DirectiveNode, ExeBlockNode, MlldNode, TextNode, VariableReference, WithClause } from '@core/types';\nimport { GuardError } from '@core/errors/GuardError';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult, EvaluationContext } from '../core/interpreter';\nimport type { ExecutableVariable, ExecutableDefinition } from '@core/types/executable';\nimport { interpolate, evaluate } from '../core/interpreter';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { MlldCommandExecutionError } from '@core/errors';\nimport type { DataLabel, SecurityDescriptor } from '@core/types/security';\nimport { makeSecurityDescriptor } from '@core/types/security';\nimport { deriveCommandTaint } from '@core/security/taint';\nimport type { CommandAnalyzer, CommandAnalysis, CommandRisk } from '@security/command/analyzer/CommandAnalyzer';\nimport type { SecurityManager } from '@security/SecurityManager';\nimport { isExecutableVariable, createSimpleTextVariable } from '@core/types/variable';\nimport type { Variable } from '@core/types/variable';\nimport type { Variable } from '@core/types/variable';\nimport { executePipeline } from './pipeline';\nimport { logger } from '@core/utils/logger';\nimport { FormatAdapterSink } from './pipeline/stream-sinks/format-adapter';\nimport { getAdapter } from '../streaming/adapter-registry';\nimport { loadStreamAdapter, resolveStreamFormatValue } from '../streaming/stream-format';\nimport { AutoUnwrapManager } from './auto-unwrap-manager';\nimport { wrapExecResult } from '../utils/structured-exec';\nimport {\n  asText,\n  normalizeWhenShowEffect,\n  applySecurityDescriptorToStructuredValue,\n  extractSecurityDescriptor\n} from '../utils/structured-value';\nimport { materializeDisplayValue } from '../utils/display-materialization';\nimport { varMxToSecurityDescriptor, hasSecurityVarMx } from '@core/types/variable/VarMxHelpers';\nimport { coerceValueForStdin } from '../utils/shell-value';\nimport { resolveDirectiveExecInvocation } from './directive-replay';\nimport { resolveWorkingDirectory } from '../utils/working-directory';\n\n/**\n * Extract raw text content from nodes without any interpolation processing\n * This preserves exact formatting and indentation for code blocks\n */\nfunction extractRawTextContent(nodes: MlldNode[]): string {\n  const parts: string[] = [];\n  for (const node of nodes) {\n    if (node.type === 'Text') {\n      parts.push(node.content || '');\n    } else if (node.type === 'Newline') {\n      parts.push('\\n');\n    } else {\n      parts.push(String((node as any).value || (node as any).content || ''));\n    }\n  }\n  const rawContent = parts.join('');\n  return rawContent.replace(/^\\n/, '');\n}\n\n/**\n * Remove common leading indentation across all non-empty lines.\n * Preserves relative indentation and trailing whitespace.\n */\nfunction dedentCommonIndent(src: string): string {\n  const lines = src.replace(/\\r\\n/g, '\\n').split('\\n');\n  let minIndent: number | null = null;\n  for (const line of lines) {\n    if (line.trim().length === 0) continue;\n    const match = line.match(/^[ \\t]*/);\n    const indent = match ? match[0].length : 0;\n    if (minIndent === null || indent < minIndent) minIndent = indent;\n    if (minIndent === 0) break;\n  }\n  if (!minIndent) return src;\n  return lines.map(l => (l.trim().length === 0 ? '' : l.slice(minIndent!))).join('\\n');\n}\n\n/**\n * Evaluate a stdin expression and coerce it into text for command execution.\n * WHY: /run supports expressions in the `with { stdin: ... }` slot that can\n *      reference variables or pipelines; those must resolve before coercion.\n * CONTEXT: Delegates final conversion to the shared shell-value helper once evaluation\n *          finishes in the command execution resolution context.\n */\nasync function resolveStdinInput(stdinSource: unknown, env: Environment): Promise<string> {\n  if (stdinSource === null || stdinSource === undefined) {\n    return '';\n  }\n\n  const result = await evaluate(stdinSource as MlldNode | MlldNode[], env, { isExpression: true });\n  let value = result.value;\n\n  if (process.env.MLLD_DEBUG_STDIN === 'true') {\n    try {\n      console.error('[mlld] stdin evaluate result', JSON.stringify(value));\n    } catch {\n      console.error('[mlld] stdin evaluate result', value);\n    }\n  }\n\n  const { isVariable, resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n  if (isVariable(value)) {\n    value = await resolveValue(value, env, ResolutionContext.CommandExecution);\n    if (process.env.MLLD_DEBUG_STDIN === 'true') {\n      try {\n        console.error('[mlld] stdin resolved variable', JSON.stringify(value));\n      } catch {\n        console.error('[mlld] stdin resolved variable', value);\n      }\n    }\n  }\n\n  return coerceValueForStdin(value);\n}\n\n/**\n * Evaluate @run directives.\n * Executes commands/code and returns output as replacement nodes.\n * \n * Ported from RunDirectiveHandler.\n */\nexport async function evaluateRun(\n  directive: DirectiveNode,\n  env: Environment,\n  callStack: string[] = [],\n  context?: EvaluationContext\n): Promise<EvalResult> {\n  // Check if we're importing - skip execution if so\n  if (env.getIsImporting()) {\n    return { value: null, env };\n  }\n\n  let outputValue: unknown;\n  let outputText: string;\n  let pendingOutputDescriptor: SecurityDescriptor | undefined;\n  let lastOutputDescriptor: SecurityDescriptor | undefined;\n  const mergePendingDescriptor = (descriptor?: SecurityDescriptor): void => {\n    if (!descriptor) {\n      return;\n    }\n    pendingOutputDescriptor = pendingOutputDescriptor\n      ? env.mergeSecurityDescriptors(pendingOutputDescriptor, descriptor)\n      : descriptor;\n  };\n  const interpolateWithPendingDescriptor = async (\n    nodes: any,\n    interpolationContext: InterpolationContext = InterpolationContext.Default,\n    targetEnv: Environment = env\n  ): Promise<string> => {\n    return interpolate(nodes, targetEnv, interpolationContext, {\n      collectSecurityDescriptor: mergePendingDescriptor\n    });\n  };\n\n  const setOutput = (value: unknown) => {\n    const wrapped = wrapExecResult(value);\n    if (pendingOutputDescriptor) {\n      const existingDescriptor =\n        wrapped.mx && hasSecurityVarMx(wrapped.mx) ? varMxToSecurityDescriptor(wrapped.mx) : undefined;\n      const descriptor = existingDescriptor\n        ? env.mergeSecurityDescriptors(existingDescriptor, pendingOutputDescriptor)\n        : pendingOutputDescriptor;\n      applySecurityDescriptorToStructuredValue(wrapped, descriptor);\n      lastOutputDescriptor = descriptor;\n      pendingOutputDescriptor = undefined;\n    } else {\n      lastOutputDescriptor = undefined;\n    }\n    outputValue = wrapped;\n    outputText = asText(wrapped as any);\n  };\n\n  setOutput('');\n  // Track source node to optionally enable stage-0 retry\n  let sourceNodeForPipeline: any | undefined;\n\n  let withClause = (directive.meta?.withClause || directive.values?.withClause) as WithClause | undefined;\n  if (process.env.MLLD_DEBUG_STDIN === 'true') {\n    try {\n      console.error('[mlld] directive meta withClause', JSON.stringify(directive.meta?.withClause));\n      console.error('[mlld] directive values withClause', JSON.stringify(directive.values?.withClause));\n    } catch {\n      console.error('[mlld] directive meta withClause', directive.meta?.withClause);\n      console.error('[mlld] directive values withClause', directive.values?.withClause);\n    }\n  }\n\n  const streamingOptions = env.getStreamingOptions();\n  const streamingRequested = Boolean(withClause && (withClause as any).stream);\n  const streamingEnabled = streamingOptions.enabled !== false && streamingRequested;\n  const pipelineId = `run-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e4)}`;\n\n  // Check for streamFormat in withClause\n  const hasStreamFormat = withClause && (withClause as any).streamFormat !== undefined;\n  const rawStreamFormat = hasStreamFormat ? (withClause as any).streamFormat : undefined;\n  const streamFormatValue = hasStreamFormat\n    ? await resolveStreamFormatValue(rawStreamFormat, env)\n    : undefined;\n\n  // Persist streamFormat/sink preferences in env so downstream executors see them\n  if (hasStreamFormat) {\n    env.setStreamingOptions({\n      ...streamingOptions,\n      streamFormat: streamFormatValue as any,\n      skipDefaultSinks: true,\n      suppressTerminal: true\n    });\n  }\n  const activeStreamingOptions = env.getStreamingOptions();\n\n  if (process.env.MLLD_DEBUG) {\n    console.error('[FormatAdapter /run] streamingEnabled:', streamingEnabled);\n    console.error('[FormatAdapter /run] hasStreamFormat:', hasStreamFormat);\n    console.error('[FormatAdapter /run] streamFormatValue:', streamFormatValue);\n    console.error('[FormatAdapter /run] withClause:', JSON.stringify(withClause));\n  }\n\n  // Setup streaming via manager\n  const streamingManager = env.getStreamingManager();\n  if (streamingEnabled) {\n    let adapter;\n    // Only use format adapter when streamFormat is explicitly specified\n    // This ensures FormatAdapterSink is used for JSON streaming (like claude --output-format stream-json)\n    // but plain text streaming (sh/bash) uses the terminal sink + normal output path\n    if (hasStreamFormat && streamFormatValue) {\n      adapter = await loadStreamAdapter(streamFormatValue);\n      if (!adapter) {\n        adapter = await getAdapter('ndjson');\n      }\n    }\n    streamingManager.configure({\n      env,\n      streamingEnabled: true,\n      streamingOptions: activeStreamingOptions,\n      adapter: adapter as any\n    });\n  }\n\n  if (streamingEnabled) {\n    const registry = env.getGuardRegistry?.();\n    const subtypeKey =\n      directive.subtype === 'runCommand'\n        ? 'runCommand'\n        : directive.subtype === 'runCode'\n          ? 'runCode'\n          : undefined;\n    const afterGuards = registry\n      ? [\n          ...registry.getOperationGuardsForTiming('run', 'after'),\n          ...(subtypeKey ? registry.getOperationGuardsForTiming(subtypeKey, 'after') : [])\n        ]\n      : [];\n    if (afterGuards.length > 0) {\n      const streamingMessage = [\n        'Cannot run after-guards when streaming is enabled.',\n        'Options:',\n        '- Remove after-timed guards or change them to before',\n        '- Disable streaming with `with { stream: false }`'\n      ].join('\\n');\n      throw new GuardError({\n        decision: 'deny',\n        message: streamingMessage,\n        reason: streamingMessage,\n        operation: {\n          type: 'run',\n          subtype: directive.subtype === 'runCode' ? 'runCode' : 'runCommand'\n        } as any,\n        timing: 'after',\n        guardResults: [],\n        reasons: [streamingMessage]\n      });\n    }\n  }\n\n  // Create execution context with source information\n  const executionContext = {\n    sourceLocation: directive.location,\n    directiveNode: directive,\n    filePath: env.getCurrentFilePath(),\n    directiveType: directive.meta?.directiveType as string || 'run'\n  };\n  \n  try {\n  if (directive.subtype === 'runCommand') {\n    // Handle command execution\n    const commandNodes = directive.values?.identifier || directive.values?.command;\n    if (!commandNodes) {\n      throw new Error('Run command directive missing command');\n    }\n    \n    const preExtractedCommand = getPreExtractedRunCommand(context);\n    // Interpolate command (resolve variables) with shell command context\n    const command =\n      preExtractedCommand ??\n      (await interpolateWithPendingDescriptor(commandNodes, InterpolationContext.ShellCommand));\n\n    const workingDirectory = await resolveWorkingDirectory(\n      (directive.values as any)?.workingDir,\n      env,\n      { sourceLocation: directive.location, directiveType: 'run' }\n    );\n    const effectiveWorkingDirectory = workingDirectory || env.getExecutionDirectory();\n    const commandTaint = deriveCommandTaint({ command });\n    mergePendingDescriptor(\n      makeSecurityDescriptor({\n        taint: commandTaint.taint,\n        labels: commandTaint.labels,\n        sources: commandTaint.sources\n      })\n    );\n\n    // Friendly pre-check for oversized simple /run command payloads\n    // Rationale: Some environments may not hit ShellCommandExecutor's guard early enough.\n    // This check ensures users see a clear suggestion before the shell invocation.\n    try {\n      const CMD_MAX = (() => {\n        const v = process.env.MLLD_MAX_SHELL_COMMAND_SIZE;\n        if (!v) return 128 * 1024; // 128KB default\n        const n = Number(v);\n        return Number.isFinite(n) && n > 0 ? Math.floor(n) : 128 * 1024;\n      })();\n      const cmdBytes = Buffer.byteLength(command || '', 'utf8');\n      if (process.env.MLLD_DEBUG === 'true') {\n        try { console.error(`[run.ts] /run command size: ${cmdBytes} bytes (max ~${CMD_MAX})`); } catch {}\n      }\n      if (cmdBytes > CMD_MAX) {\n        const message = [\n          'Command payload too large for /run execution (may exceed OS args+env limits).',\n          `Command size: ${cmdBytes} bytes (max ~${CMD_MAX})`,\n          'Suggestions:',\n          '- Use `/run sh (@var) { echo \"$var\" | tool }` or `/exe ... = sh { ... }` to leverage heredocs',\n          '- Pass file paths or stream via stdin (printf, here-strings)',\n          '- Reduce or split the data',\n          '',\n          'Learn more: https://mlld.ai/docs/large-variables'\n        ].join('\\n');\n        throw new MlldCommandExecutionError(\n          message,\n          directive.location,\n          {\n            command,\n            exitCode: 1,\n            duration: 0,\n            stderr: message,\n            workingDirectory: effectiveWorkingDirectory,\n            directiveType: 'run'\n          },\n          env\n        );\n      }\n    } catch (e) {\n      if (e instanceof MlldCommandExecutionError) {\n        throw e;\n      }\n      // Non-fatal sizing errors should not block execution\n    }\n    \n    /**\n     * Security check before command execution\n     * WHY: Commands must be analyzed for potential security risks before execution\n     * to prevent command injection, data exfiltration, and system damage.\n     * SECURITY: Multi-layer defense with taint tracking, command analysis, and\n     * policy enforcement. Blocks dangerous commands and warns about risky ones.\n     * CONTEXT: Security manager is optional but when present, all commands are\n     * analyzed. Analysis considers both command structure and taint level.\n     */\n    const security = env.getSecurityManager();\n    if (security) {\n      // Use command analyzer to check the command\n      const securityManager = security as SecurityManager & { commandAnalyzer?: CommandAnalyzer };\n      const analyzer = securityManager.commandAnalyzer;\n      if (analyzer) {\n        const analysis = await analyzer.analyze(command, commandTaint.taint);\n        \n        // Block immediately dangerous commands\n        if (analysis.blocked) {\n          const reason = analysis.risks[0]?.description || 'Security policy violation';\n        throw new MlldCommandExecutionError(\n          `Security: Command blocked - ${reason}`,\n          directive.location,\n          {\n            command,\n            exitCode: 1,\n            duration: 0,\n            stderr: `This command is blocked by security policy: ${reason}`,\n            workingDirectory: effectiveWorkingDirectory,\n            directiveType: 'run'\n          },\n          env\n        );\n        }\n        // TODO: Add approval prompts for suspicious commands\n        // Temporarily disable security warnings for cleaner output\n        /*\n        if (analysis.risks.length > 0) {\n          console.warn(`⚠️  Security warning for command: ${command}`);\n          for (const risk of analysis.risks) {\n            console.warn(`   - ${risk.type}: ${risk.description}`);\n          }\n        }\n        */\n      }\n    }\n    \n    // Execute the command with context for rich error reporting\n    let stdinInput: string | undefined;\n    if (withClause && 'stdin' in withClause) {\n      stdinInput = await resolveStdinInput(withClause.stdin, env);\n    }\n\n    const commandOptions =\n      stdinInput !== undefined || workingDirectory\n        ? {\n            ...(stdinInput !== undefined ? { input: stdinInput } : {}),\n            ...(workingDirectory ? { workingDirectory } : {})\n          }\n        : undefined;\n    setOutput(await env.executeCommand(command, commandOptions, {\n      ...executionContext,\n      streamingEnabled,\n      pipelineId,\n      suppressTerminal: hasStreamFormat || activeStreamingOptions.suppressTerminal === true,\n      workingDirectory\n    }));\n    \n  } else if (directive.subtype === 'runCode') {\n    // Handle code execution\n    const codeNodes = directive.values?.code;\n    if (!codeNodes) {\n      throw new Error('Run code directive missing code');\n    }\n    \n    // Verbatim code (no interpolation) with dedent to avoid top-level indent issues\n    const code = dedentCommonIndent(extractRawTextContent(codeNodes));\n    const workingDirectory = await resolveWorkingDirectory(\n      (directive.values as any)?.workingDir,\n      env,\n      { sourceLocation: directive.location, directiveType: 'run' }\n    );\n    \n    // Handle arguments passed to code blocks (e.g., /run js (@var1, @var2) {...})\n    const args = directive.values?.args || [];\n    const argValues: Record<string, any> =\n      args.length === 0\n        ? {}\n        : await AutoUnwrapManager.executeWithPreservation(async () => {\n            const extracted: Record<string, any> = {};\n            for (let i = 0; i < args.length; i++) {\n              const arg = args[i];\n\n              if (arg && typeof arg === 'object' && arg.type === 'VariableReference') {\n                // This is a variable reference like @myVar\n                const varName = arg.identifier;\n                const variable = env.getVariable(varName);\n                if (!variable) {\n                  throw new Error(`Variable not found: ${varName}`);\n                }\n\n                // Extract the variable value\n                const { extractVariableValue } = await import('../utils/variable-resolution');\n                const value = await extractVariableValue(variable, env);\n\n                // Auto-unwrap LoadContentResult objects\n                const unwrappedValue = AutoUnwrapManager.unwrap(value);\n\n                // The parameter name in the code will be the variable name without @\n                extracted[varName] = unwrappedValue;\n              } else if (typeof arg === 'string') {\n                // Simple string argument - shouldn't happen with current grammar\n                // but handle it just in case\n                extracted[`arg${i}`] = arg;\n              }\n            }\n            return extracted;\n          });\n    \n    // Execute the code (default to JavaScript) with context for errors\n    const language = (directive.meta?.language as string) || 'javascript';\n    setOutput(await AutoUnwrapManager.executeWithPreservation(async () => {\n      return await env.executeCode(\n        code,\n        language,\n        argValues,\n        undefined,\n        workingDirectory ? { workingDirectory } : undefined,\n        {\n          ...executionContext,\n          streamingEnabled,\n          pipelineId,\n          workingDirectory\n        }\n      );\n    }));\n    \n  } else if (directive.subtype === 'runExec') {\n    // Handle exec reference with field access support\n    const identifierNodes = directive.values?.identifier;\n    if (!identifierNodes || !Array.isArray(identifierNodes) || identifierNodes.length === 0) {\n      throw new Error('Run exec directive missing exec reference');\n    }\n    \n    // Extract command name first for call stack tracking\n    let commandName: string = '';\n    const identifierNode = identifierNodes[0];\n    \n    // With improved type consistency, identifierNodes is always VariableReferenceNode[]\n    if (identifierNode.type === 'VariableReference' && 'identifier' in identifierNode) {\n      commandName = identifierNode.identifier;\n    }\n    \n    // Add current command to call stack if not already there\n    if (commandName && !callStack.includes(commandName)) {\n      callStack = [...callStack, commandName];\n    }\n    \n    // Check if this is a field access pattern (e.g., @http.get)\n    let execVar: ExecutableVariable;\n    \n    if (identifierNode.type === 'VariableReference' && (identifierNode as VariableReference).fields && (identifierNode as VariableReference).fields.length > 0) {\n      // Handle field access (e.g., @http.get)\n      const varRef = identifierNode as VariableReference;\n      const baseVar = env.getVariable(varRef.identifier);\n      if (!baseVar) {\n        throw new Error(`Base variable not found: ${varRef.identifier}`);\n      }\n      \n      const variantMap = baseVar.internal?.transformerVariants as Record<string, any> | undefined;\n      let value: any;\n      let remainingFields = Array.isArray(varRef.fields) ? [...varRef.fields] : [];\n\n      if (variantMap && remainingFields.length > 0) {\n        const firstField = remainingFields[0];\n        if (firstField.type === 'field' || firstField.type === 'stringIndex' || firstField.type === 'numericField') {\n          const variantName = String(firstField.value);\n          const variant = variantMap[variantName];\n          if (!variant) {\n            throw new Error(`Pipeline function '@${varRef.identifier}.${variantName}' is not defined`);\n          }\n          value = variant;\n          remainingFields = remainingFields.slice(1);\n        }\n      }\n\n      if (typeof value === 'undefined') {\n        // Extract Variable value for field access - WHY: Need raw object to navigate fields\n        const { extractVariableValue } = await import('../utils/variable-resolution');\n        value = await extractVariableValue(baseVar, env);\n      }\n\n      // Navigate through the remaining field access chain\n      for (const field of remainingFields) {\n        if ((field.type === 'field' || field.type === 'stringIndex' || field.type === 'numericField') && typeof value === 'object' && value !== null) {\n          value = (value as Record<string, unknown>)[String(field.value)];\n        } else if (field.type === 'arrayIndex' && Array.isArray(value)) {\n          value = value[Number(field.value)];\n        } else {\n          const fieldName = String(field.value);\n          throw new Error(`Cannot access field '${fieldName}' on ${typeof value}`);\n        }\n      }\n      \n      \n      // The resolved value could be an executable object directly or a string reference\n      if (typeof value === 'object' && value !== null && 'type' in value && value.type === 'executable') {\n        // Direct executable object\n        execVar = value as ExecutableVariable;\n      } else if (typeof value === 'object' && value !== null && '__executable' in value && value.__executable) {\n        // Serialized executable object from imports/exports\n        // Manually reconstruct the ExecutableVariable with all metadata\n        const fullName = `${varRef.identifier}.${varRef.fields.map(f => f.value).join('.')}`;\n        \n        // Deserialize shadow environments if present (convert objects back to Maps)\n        let capturedShadowEnvs = value.internal?.capturedShadowEnvs;\n        if (capturedShadowEnvs && typeof capturedShadowEnvs === 'object') {\n          const deserialized: any = {};\n          for (const [lang, shadowObj] of Object.entries(capturedShadowEnvs)) {\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              deserialized[lang] = map;\n            }\n          }\n          capturedShadowEnvs = deserialized;\n        }\n        \n        execVar = {\n          type: 'executable',\n          name: fullName,\n          value: value.value || { type: 'code', template: '', language: 'js' },\n          paramNames: value.paramNames || [],\n          source: {\n            directive: 'import',\n            syntax: 'code',\n            hasInterpolation: false,\n            isMultiLine: false\n          },\n          createdAt: Date.now(),\n          modifiedAt: Date.now(),\n          mx: {\n            ...(value.mx || {})\n          },\n          internal: {\n            ...(value.internal || {}),\n            executableDef: value.executableDef,\n            // CRITICAL: Preserve captured shadow environments from imports (deserialized)\n            capturedShadowEnvs: capturedShadowEnvs\n          }\n        };\n        \n      } else if (typeof value === 'string') {\n        // String reference to an executable  \n        const variable = env.getVariable(value);\n        if (!variable || !isExecutableVariable(variable)) {\n          throw new Error(`Executable variable not found: ${value}`);\n        }\n        execVar = variable;\n      } else {\n        throw new Error(`Field access did not resolve to an executable: ${typeof value}, got: ${JSON.stringify(value)}`);\n      }\n    } else {\n      // Handle simple command reference (original behavior)\n      // Command name already extracted above\n      if (!commandName) {\n        throw new Error('Run exec directive identifier must be a command reference');\n      }\n      \n      const variable = getPreExtractedExec(context, commandName) ?? env.getVariable(commandName);\n      if (!variable || !isExecutableVariable(variable)) {\n        throw new Error(`Executable variable not found: ${commandName}`);\n      }\n      execVar = variable;\n    }\n    \n    // Get the executable definition from metadata\n    const definition = execVar.internal?.executableDef as ExecutableDefinition | undefined;\n    if (!definition) {\n      // For field access, provide more helpful error message\n      const fullPath = identifierNode.type === 'VariableReference' && (identifierNode as VariableReference).fields && (identifierNode as VariableReference).fields.length > 0\n        ? `${(identifierNode as VariableReference).identifier}.${(identifierNode as VariableReference).fields.map(f => f.value).join('.')}`\n        : commandName;\n      throw new Error(`Executable ${fullPath} has no definition (missing executableDef)`);\n    }\n    \n    // Get arguments from the run directive\n    const args = directive.values?.args || [];\n    const argValues: Record<string, string> = {};\n    \n    // Map parameter names to argument values\n    const paramNames = definition.paramNames as string[] | undefined;\n    if (paramNames && paramNames.length > 0) {\n      for (let i = 0; i < paramNames.length; i++) {\n        const paramName = paramNames[i];\n        if (!args[i]) {\n          argValues[paramName] = '';\n          continue;\n        }\n        \n        // Handle argument nodes\n        const arg = args[i];\n        \n        // Handle both primitive values and node objects\n        let argValue: string;\n        if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {\n          // Primitive value from grammar\n          argValue = String(arg);\n        } else if (arg && typeof arg === 'object' && 'type' in arg) {\n          // Node object - interpolate normally\n          argValue = await interpolateWithPendingDescriptor([arg], InterpolationContext.Default);\n        } else {\n          // Fallback\n          argValue = String(arg);\n        }\n        argValues[paramName] = argValue;\n      }\n    }\n    \n    if (definition.type === 'command' && 'commandTemplate' in definition) {\n      // Create a temporary environment with parameter values\n      const tempEnv = env.createChild();\n      for (const [key, value] of Object.entries(argValues)) {\n        tempEnv.setParameterVariable(key, createSimpleTextVariable(key, value));\n      }\n\n      const workingDirectory = await resolveWorkingDirectory(\n        (definition as any)?.workingDir,\n        tempEnv,\n        { sourceLocation: directive.location, directiveType: 'run' }\n      );\n      const effectiveWorkingDirectory = workingDirectory || env.getExecutionDirectory();\n      \n      // TODO: Remove this workaround when issue #51 is fixed\n      // Strip leading '[' from first command segment if present\n      const cleanTemplate = definition.commandTemplate.map((seg: MlldNode, idx: number) => {\n        if (idx === 0 && seg.type === 'Text' && 'content' in seg && seg.content.startsWith('[')) {\n          return { ...seg, content: seg.content.substring(1) };\n        }\n        return seg;\n      });\n      \n      // Interpolate the command template with parameters\n      const command = await interpolateWithPendingDescriptor(\n        cleanTemplate,\n        InterpolationContext.ShellCommand,\n        tempEnv\n      );\n      \n      // NEW: Security check for exec commands\n      const security = env.getSecurityManager();\n      if (security) {\n        const securityManager = security as SecurityManager & { commandAnalyzer?: CommandAnalyzer };\n        const analyzer = securityManager.commandAnalyzer;\n        if (analyzer) {\n          const analysis = await analyzer.analyze(command);\n          if (analysis.blocked) {\n            const reason = analysis.risks?.[0]?.description || 'Security policy violation';\n            throw new MlldCommandExecutionError(\n              `Security: Exec command blocked - ${reason}`,\n              directive.location,\n            {\n              command,\n              exitCode: 1,\n              duration: 0,\n              stderr: `This exec command is blocked by security policy: ${reason}`,\n              workingDirectory: effectiveWorkingDirectory,\n              directiveType: 'run'\n            },\n            env\n          );\n        }\n        }\n      }\n      \n      // Pass context for exec command errors too\n      setOutput(await env.executeCommand(command, workingDirectory ? { workingDirectory } : undefined, {\n        ...executionContext,\n        streamingEnabled,\n        pipelineId,\n        workingDirectory\n      }));\n      \n    } else if (definition.type === 'commandRef') {\n      // This command references another command\n      const refExecVar = env.getVariable(definition.commandRef);\n      if (!refExecVar || !isExecutableVariable(refExecVar)) {\n        throw new Error(`Referenced executable not found: ${definition.commandRef}`);\n      }\n      \n      // Check for circular references\n      if (callStack.includes(definition.commandRef)) {\n        const cycle = [...callStack, definition.commandRef].join(' -> ');\n        throw new Error(`Circular command reference detected: ${cycle}`);\n      }\n      \n      // Create a new run directive for the referenced command\n      const refDirective = {\n        ...directive,\n        values: {\n          ...directive.values,\n          identifier: [{ type: 'Text', content: definition.commandRef }],\n          args: definition.commandArgs\n        }\n      };\n      \n      // Recursively evaluate the referenced command with updated call stack\n      // Note: We don't add definition.commandRef here because it will be added \n      // at the beginning of the runExec case when processing refDirective\n      const result = await evaluateRun(refDirective, env, callStack);\n      setOutput(result.value);\n      \n    } else if (definition.type === 'code') {\n      const tempEnv = env.createChild();\n      for (const [key, value] of Object.entries(argValues)) {\n        tempEnv.setParameterVariable(key, createSimpleTextVariable(key, value));\n      }\n      const workingDirectory = await resolveWorkingDirectory(\n        (definition as any)?.workingDir,\n        tempEnv,\n        { sourceLocation: directive.location, directiveType: 'run' }\n      );\n      \n      const codeParams = { ...argValues };\n      const capturedEnvs = execVar.internal?.capturedShadowEnvs;\n      if (capturedEnvs && (definition.language === 'js' || definition.language === 'javascript' || \n                           definition.language === 'node' || definition.language === 'nodejs')) {\n        (codeParams as any).__capturedShadowEnvs = capturedEnvs;\n      }\n      \n      // Special handling for mlld-when expressions\n      if (definition.language === 'mlld-when') {\n        logger.debug('🎯 mlld-when handler in run.ts CALLED');\n        \n        // The codeTemplate contains the WhenExpression node\n        const whenExprNode = definition.codeTemplate[0];\n        if (!whenExprNode || whenExprNode.type !== 'WhenExpression') {\n          throw new Error('mlld-when executable missing WhenExpression node');\n        }\n        \n        // Create parameter environment\n        const execEnv = env.createChild();\n        for (const [key, value] of Object.entries(codeParams)) {\n          execEnv.setParameterVariable(key, createSimpleTextVariable(key, value));\n        }\n        \n        // Evaluate the when expression with the parameter environment\n        const { evaluateWhenExpression } = await import('./when-expression');\n        const whenResult = await evaluateWhenExpression(whenExprNode, execEnv);\n        // If the when-expression tagged a side-effect show, unwrap to its text\n        // so /run echoes it as output (tests expect duplicate lines).\n        const normalized = normalizeWhenShowEffect(whenResult.value);\n        setOutput(normalized.normalized);\n        \n        logger.debug('🎯 mlld-when result:', {\n          outputType: typeof outputValue,\n          outputValue: outputText.substring(0, 100)\n        });\n      } else if (definition.language === 'mlld-exe-block') {\n        const blockNode = Array.isArray(definition.codeTemplate)\n          ? (definition.codeTemplate[0] as ExeBlockNode | undefined)\n          : undefined;\n        if (!blockNode || !blockNode.values) {\n          throw new Error('mlld-exe-block executable missing block content');\n        }\n\n        const execEnv = env.createChild();\n        for (const [key, value] of Object.entries(codeParams)) {\n          execEnv.setParameterVariable(key, createSimpleTextVariable(key, value));\n        }\n\n        const { evaluateExeBlock } = await import('./exe');\n        const blockResult = await evaluateExeBlock(blockNode, execEnv);\n        setOutput(blockResult.value);\n      } else {\n        // Interpolate executable code templates with parameters (canonical behavior)\n        const code = await interpolateWithPendingDescriptor(\n          definition.codeTemplate,\n          InterpolationContext.ShellCommand,\n          tempEnv\n        );\n        if (process.env.DEBUG_EXEC) {\n          logger.debug('run.ts code execution debug:', {\n            codeTemplate: definition.codeTemplate,\n            interpolatedCode: code,\n            argValues\n          });\n        }\n\n        setOutput(await AutoUnwrapManager.executeWithPreservation(async () => {\n          return await env.executeCode(\n            code,\n            definition.language || 'javascript',\n            codeParams,\n            undefined,\n            workingDirectory ? { workingDirectory } : undefined,\n            {\n              ...executionContext,\n              streamingEnabled,\n              pipelineId,\n              workingDirectory\n            }\n          );\n        }));\n      }\n    } else if (definition.type === 'template') {\n      // Handle template executables\n      const tempEnv = env.createChild();\n      for (const [key, value] of Object.entries(argValues)) {\n        tempEnv.setParameterVariable(key, createSimpleTextVariable(key, value));\n      }\n\n      const templateOutput = await interpolateWithPendingDescriptor(\n        definition.template,\n        InterpolationContext.Default,\n        tempEnv\n      );\n      setOutput(templateOutput);\n    } else if (definition.type === 'prose') {\n      // Handle prose executables - prose:@config { ... }\n      const { executeProseExecutable } = await import('./prose-execution');\n      const proseResult = await executeProseExecutable(definition, argValues, env);\n      setOutput(proseResult);\n    } else {\n      throw new Error(`Unsupported executable type: ${definition.type}`);\n    }\n  } else if (directive.subtype === 'runExecInvocation') {\n    // Handle ExecInvocation nodes in run directive\n    const execInvocation = directive.values?.execInvocation;\n    if (!execInvocation) {\n      throw new Error('Run exec invocation directive missing exec invocation');\n    }\n    \n    // Evaluate the exec invocation\n    const result = await resolveDirectiveExecInvocation(directive, env, execInvocation);\n    setOutput(result.value);\n    sourceNodeForPipeline = execInvocation;\n    \n  } else if (directive.subtype === 'runExecReference') {\n    // Handle exec reference nodes in run directive (from @when actions)\n    const execRef = directive.values?.execRef;\n    if (!execRef) {\n      throw new Error('Run exec reference directive missing exec reference');\n    }\n\n    // Evaluate the exec invocation\n    const result = await resolveDirectiveExecInvocation(directive, env, execRef);\n    setOutput(result.value);\n    sourceNodeForPipeline = execRef;\n\n  } else if (directive.subtype === 'runPipeline') {\n    // Handle leading parallel pipeline: /run || @a() || @b()\n    // Pipeline is already in withClause, initial input is empty string\n    setOutput('');\n    withClause = directive.values.withClause;\n\n  } else {\n    throw new Error(`Unsupported run subtype: ${directive.subtype}`);\n  }\n  \n  // Handle with clause if present\n  if (withClause) {\n    if (process.env.MLLD_DEBUG_STDIN === 'true') {\n      try {\n        console.error('[mlld] withClause', JSON.stringify(withClause, null, 2));\n      } catch {\n        console.error('[mlld] withClause', withClause);\n      }\n    }\n    // Apply pipeline transformations if specified\n    if (withClause.pipeline && withClause.pipeline.length > 0) {\n      // Use unified pipeline processor\n      const { processPipeline } = await import('./pipeline/unified-processor');\n      // Stage-0 retry is always enabled when we have a source node\n      const enableStage0 = !!sourceNodeForPipeline;\n      const pipelineInput = outputValue;\n      const valueForPipeline = enableStage0\n        ? { value: pipelineInput, mx: {}, internal: { isRetryable: true, sourceFunction: sourceNodeForPipeline } }\n        : pipelineInput;\n      const outputDescriptor = lastOutputDescriptor ?? extractSecurityDescriptor(pipelineInput, {\n        recursive: true,\n        mergeArrayElements: true\n      });\n      const pipelineDescriptorHint = pendingOutputDescriptor\n        ? outputDescriptor\n          ? env.mergeSecurityDescriptors(pendingOutputDescriptor, outputDescriptor)\n          : pendingOutputDescriptor\n        : outputDescriptor;\n      const pipelineResult = await processPipeline({\n        value: valueForPipeline,\n        env,\n        directive,\n        pipeline: withClause.pipeline,\n        format: withClause.format as string | undefined,\n        isRetryable: enableStage0,\n        location: directive.location,\n        descriptorHint: pipelineDescriptorHint\n      });\n      setOutput(pipelineResult);\n    }\n  }\n\n  // Cleanup streaming sinks and capture adapter output\n  const finalizedStreaming = streamingManager.finalizeResults();\n  env.setStreamingResult(finalizedStreaming.streaming);\n\n  // When using format adapter, use the accumulated formatted text from the adapter\n  // instead of the raw command output\n  if (hasStreamFormat && finalizedStreaming.streaming?.text) {\n    outputText = finalizedStreaming.streaming.text;\n    // Update outputValue to match the formatted text\n    setOutput(outputText);\n  }\n\n  // Output directives always end with a newline for display\n  let displayText = outputText;\n  if (!displayText.endsWith('\\n')) {\n    displayText += '\\n';\n  }\n  outputText = displayText;\n\n  // Only add output nodes for non-embedded directives\n  if (!directive.meta?.isDataValue && !directive.meta?.isEmbedded) {\n    // Create replacement text node with the output\n    const replacementNode: TextNode = {\n      type: 'Text',\n      nodeId: `${directive.nodeId}-output`,\n      content: displayText\n    };\n\n    // Add the replacement node to environment\n    env.addNode(replacementNode);\n  }\n\n  // Emit effect only for top-level run directives (not data/RHS contexts)\n  // Skip emission when using format adapter (adapter already emitted during streaming)\n  const shouldEmitFinalOutput = !hasStreamFormat || !streamingEnabled;\n  if (displayText && !directive.meta?.isDataValue && !directive.meta?.isEmbedded && !directive.meta?.isRHSRef && shouldEmitFinalOutput) {\n    const materializedEffect = materializeDisplayValue(\n      outputValue,\n      undefined,\n      outputValue,\n      displayText\n    );\n    const effectText = materializedEffect.text;\n    if (materializedEffect.descriptor) {\n      env.recordSecurityDescriptor(materializedEffect.descriptor);\n    }\n    env.emitEffect('both', effectText);\n  }\n\n  // Return the output value\n  return {\n    value: outputValue,\n    env\n  };\n  } catch (error) {\n    throw error;\n  } finally {\n    // Streaming cleanup already done above (moved out of finally to use results)\n  }\n}\n\nfunction getPreExtractedRunCommand(context?: EvaluationContext): string | undefined {\n  if (!context?.extractedInputs || context.extractedInputs.length === 0) {\n    return undefined;\n  }\n  for (const input of context.extractedInputs) {\n    if (\n      input &&\n      typeof input === 'object' &&\n      'name' in input &&\n      (input as any).name === '__run_command__' &&\n      typeof (input as any).value === 'string'\n    ) {\n      return (input as any).value as string;\n    }\n  }\n  return undefined;\n}\n\nfunction getPreExtractedExec(\n  context: EvaluationContext | undefined,\n  name: string\n): ExecutableVariable | undefined {\n  if (!context?.extractedInputs || context.extractedInputs.length === 0) {\n    return undefined;\n  }\n  for (const input of context.extractedInputs) {\n    if (\n      input &&\n      typeof input === 'object' &&\n      'name' in input &&\n      (input as Variable).name === name &&\n      (input as Variable).type === 'executable'\n    ) {\n      return input as ExecutableVariable;\n    }\n  }\n  return undefined;\n}\n","import type { DirectiveNode, ContentNode } from '@core/types';\nimport type { ImportType, SecurityDescriptor } from '@core/types/security';\nimport type { Environment } from '../../env/Environment';\nimport { interpolate } from '../../core/interpreter';\n\nexport interface ImportResolution {\n  type: 'file' | 'url' | 'module' | 'resolver' | 'input';\n  resolvedPath: string;\n  expectedHash?: string;\n  resolverName?: string;\n  sectionName?: string;\n  moduleExtension?: string;\n  importType?: ImportType;\n  cacheDurationMs?: number;\n  preferLocal?: boolean;\n}\n\ntype ContentNodeArray = ContentNode[];\n\n/**\n * Handles import path processing and resolution routing\n */\nexport class ImportPathResolver {\n  constructor(private env: Environment) {}\n\n  /**\n   * Resolve import path and determine the type of import\n   */\n  async resolveImportPath(directive: DirectiveNode): Promise<ImportResolution> {\n    // Get the path to import\n    const pathValue = directive.values?.path;\n    if (!pathValue) {\n      throw new Error('Import directive missing path');\n    }\n\n    // Convert path to node array for consistent processing\n    const pathNodes = this.normalizePathNodes(pathValue, directive);\n\n    // Check for special imports first (input, stdin, resolvers)\n    const specialImport = await this.detectSpecialImports(pathNodes, directive);\n    if (specialImport) {\n      return specialImport;\n    }\n\n    // Interpolate the path nodes to get the final import path\n    const importPath = await this.interpolatePathNodes(pathNodes);\n\n    // Determine import type and resolve the path\n    return this.routeImportRequest(importPath, pathNodes, directive);\n  }\n\n  /**\n   * Convert path value to consistent node array format\n   */\n  private normalizePathNodes(pathValue: any, directive: DirectiveNode): ContentNodeArray {\n    if (typeof pathValue === 'string') {\n      // Legacy string path handling - convert to node array\n      return [{ type: 'Text', content: pathValue, nodeId: '', location: directive.location }];\n    } else if (Array.isArray(pathValue)) {\n      // Normal case: pathValue is already an array of nodes\n      return pathValue;\n    } else if (pathValue && typeof pathValue === 'object' && pathValue.type === 'path') {\n      // Handle path objects (e.g., URL paths in brackets: [https://example.com/file.mld])\n      if (pathValue.subtype === 'urlPath' && pathValue.values?.url) {\n        // URL path - extract the URL content\n        return pathValue.values.url;\n      } else if (pathValue.values?.path) {\n        // Regular path object - extract the path content\n        return pathValue.values.path;\n      } else {\n        throw new Error('Invalid path object structure in import directive');\n      }\n    } else {\n      throw new Error('Import directive path must be a string, array of nodes, or path object');\n    }\n  }\n\n  /**\n   * Detect special imports (@input, @stdin, resolver imports)\n   * Also handles \"liberal\" quoted syntax like \"@local/module\" where @local is a resolver\n   */\n  private async detectSpecialImports(\n    pathNodes: ContentNodeArray,\n    directive: DirectiveNode\n  ): Promise<ImportResolution | null> {\n    if (pathNodes.length === 0) {\n      return null;\n    }\n\n    const firstNode = pathNodes[0];\n\n    // Handle text-based special imports\n    if (firstNode.type === 'Text') {\n      const content = firstNode.content;\n      if (content === '@INPUT' || content === '@input') {\n        return {\n          type: 'input',\n          resolvedPath: '@input',\n          resolverName: 'input'\n        };\n      } else if (content === '@stdin') {\n        // Silently handle @stdin for backward compatibility\n        return {\n          type: 'input',\n          resolvedPath: '@input',\n          resolverName: 'input'\n        };\n      } else if (content === '@state' || content === '@payload') {\n        return {\n          type: 'module',\n          resolvedPath: content\n        };\n      }\n    }\n\n    // Handle variable reference special imports\n    if (firstNode.type === 'VariableReference') {\n      const varRef = firstNode as any;\n\n      if (varRef.identifier === 'state' || varRef.identifier === 'payload') {\n        return {\n          type: 'module',\n          resolvedPath: `@${varRef.identifier}`\n        };\n      }\n\n      // Handle @input/@stdin as variable references\n      if (varRef.identifier === 'INPUT' || varRef.identifier === 'input') {\n        return {\n          type: 'input',\n          resolvedPath: '@input',\n          resolverName: 'input'\n        };\n      } else if (varRef.identifier === 'stdin') {\n        return {\n          type: 'input',\n          resolvedPath: '@input',\n          resolverName: 'input'\n        };\n      }\n\n      // Handle resolver imports with isSpecial flag\n      // But only if there's no path following (e.g., @TIME alone, not @base/path)\n      if (varRef.isSpecial && varRef.identifier && pathNodes.length === 1) {\n        const resolverManager = this.env.getResolverManager();\n        if (resolverManager) {\n          if (resolverManager.isResolverName(varRef.identifier)) {\n            return {\n              type: 'resolver',\n              resolvedPath: `@${varRef.identifier}`,\n              resolverName: varRef.identifier\n            };\n          }\n          const dynamicResolver = resolverManager.findResolverForRef?.(`@${varRef.identifier}`);\n          if (dynamicResolver) {\n            return {\n              type: 'resolver',\n              resolvedPath: `@${varRef.identifier}`,\n              resolverName: dynamicResolver.name\n            };\n          }\n        }\n      }\n\n      // Handle quoted paths like \"@author/module\" that should be module references\n      // (not resolver paths like @base or @local, which resolve to file system paths)\n      // This supports Postel's Law - \"be liberal in what you accept\"\n      const resolverManager = this.env.getResolverManager();\n      if (varRef.isSpecial && varRef.identifier) {\n        const potentialName = varRef.identifier;\n\n        // If this is a known resolver (e.g., @base, @local), let it go through\n        // normal interpolation - the resolver will expand to a path\n        if (resolverManager && resolverManager.isResolverName(potentialName)) {\n          // Don't intercept - let interpolation handle it\n          return null;\n        }\n\n        // Build the full path from remaining nodes\n        // Handle both Text nodes and PathSeparator nodes\n        const remainingPath = pathNodes.slice(1)\n          .map(node => {\n            if (node.type === 'Text') {\n              return (node as any).content;\n            } else if (node.type === 'PathSeparator') {\n              return (node as any).value || '/';\n            }\n            return '';\n          })\n          .join('');\n\n        // For non-resolver namespaces like @author/module, treat as module reference\n        if (remainingPath.startsWith('/') || remainingPath.length > 0) {\n          const fullRef = `@${potentialName}${remainingPath.startsWith('/') ? '' : '/'}${remainingPath}`;\n          return {\n            type: 'module',\n            resolvedPath: fullRef\n          };\n        }\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Interpolate path nodes to get the final import path\n   */\n  private async interpolatePathNodes(pathNodes: ContentNodeArray): Promise<string> {\n    // Regular path interpolation - handles liberal import syntax through normal interpolation\n    const descriptors: SecurityDescriptor[] = [];\n    const interpolated = await interpolate(pathNodes, this.env, undefined, {\n      collectSecurityDescriptor: descriptor => {\n        if (descriptor) {\n          descriptors.push(descriptor);\n        }\n      }\n    });\n    const merged =\n      descriptors.length === 1\n        ? descriptors[0]\n        : descriptors.length > 1\n          ? this.env.mergeSecurityDescriptors(...descriptors)\n          : undefined;\n    if (merged) {\n      this.env.recordSecurityDescriptor(merged);\n    }\n    return interpolated.trim();\n  }\n\n  /**\n   * Route import request based on the interpolated path\n   */\n  private async routeImportRequest(\n    importPath: string,\n    pathNodes: ContentNodeArray,\n    directive: DirectiveNode\n  ): Promise<ImportResolution> {\n    // Extract section name if specified\n    const sectionNodes = directive.values?.section;\n    let sectionName: string | undefined;\n    if (sectionNodes && Array.isArray(sectionNodes)) {\n      const sectionDescriptors: SecurityDescriptor[] = [];\n      sectionName = await interpolate(sectionNodes, this.env, undefined, {\n        collectSecurityDescriptor: descriptor => {\n          if (descriptor) {\n            sectionDescriptors.push(descriptor);\n          }\n        }\n      });\n      const mergedSection =\n        sectionDescriptors.length === 1\n          ? sectionDescriptors[0]\n          : sectionDescriptors.length > 1\n            ? this.env.mergeSecurityDescriptors(...sectionDescriptors)\n            : undefined;\n      if (mergedSection) {\n        this.env.recordSecurityDescriptor(mergedSection);\n      }\n    }\n\n    // Check if this is a module reference (@prefix/ pattern)\n    if (importPath.startsWith('@')) {\n      return this.handleModuleReference(importPath, directive, sectionName);\n    }\n\n    // Check if this is a URL\n    const pathNode = pathNodes[0];\n    const isURL = pathNode?.subtype === 'urlPath' || \n                  pathNode?.subtype === 'urlSectionPath' || \n                  this.env.isURL(importPath);\n\n    if (isURL) {\n      return this.handleURLImport(importPath, directive, sectionName);\n    }\n\n    // Handle file path\n    return this.handleFileImport(importPath, directive, sectionName);\n  }\n\n  /**\n   * Handle module reference imports (@user/module, @now, etc.)\n   */\n  private async handleModuleReference(\n    importPath: string,\n    directive: DirectiveNode,\n    sectionName?: string\n  ): Promise<ImportResolution> {\n    // First check if it's a resolver name (like @TIME, @DEBUG, etc.)\n    const resolverManager = this.env.getResolverManager();\n    const potentialResolverName = importPath.substring(1); // Remove @ prefix\n    \n    if (resolverManager && resolverManager.isResolverName(potentialResolverName)) {\n      return {\n        type: 'resolver',\n        resolvedPath: importPath,\n        resolverName: potentialResolverName,\n        sectionName\n      };\n    }\n\n    // Extract hash from the module reference if present\n    const { moduleRef, expectedHash, extension } = this.extractHashFromPath(importPath, directive);\n\n    return {\n      type: 'module',\n      resolvedPath: moduleRef,\n      expectedHash,\n      sectionName,\n      moduleExtension: extension\n    };\n  }\n\n  /**\n   * Handle URL imports\n   */\n  private async handleURLImport(\n    importPath: string,\n    directive: DirectiveNode,\n    sectionName?: string\n  ): Promise<ImportResolution> {\n    // Extract hash if present in metadata\n    const pathMeta = directive.meta?.path;\n    const expectedHash = pathMeta?.hash;\n\n    return {\n      type: 'url',\n      resolvedPath: importPath,\n      expectedHash,\n      sectionName\n    };\n  }\n\n  /**\n   * Handle file path imports\n   */\n  private async handleFileImport(\n    importPath: string,\n    directive: DirectiveNode,\n    sectionName?: string\n  ): Promise<ImportResolution> {\n    // Resolve relative to current basePath\n    const resolvedPath = await this.env.resolvePath(importPath);\n    \n    // Extract hash if present in metadata\n    const pathMeta = directive.meta?.path;\n    const expectedHash = pathMeta?.hash;\n\n    return {\n      type: 'file',\n      resolvedPath,\n      expectedHash,\n      sectionName\n    };\n  }\n\n  /**\n   * Extract hash information from module reference\n   */\n  private extractHashFromPath(\n    importPath: string, \n    directive: DirectiveNode\n  ): { moduleRef: string; expectedHash?: string; extension?: string } {\n    let moduleRef = importPath;\n    let expectedHash: string | undefined;\n    let extension: string | undefined;\n\n    const pathMeta = directive.meta?.path;\n\n    if (pathMeta && pathMeta.hash) {\n      expectedHash = pathMeta.hash;\n      const hashIndex = moduleRef.lastIndexOf('@');\n      if (hashIndex > 0) {\n        moduleRef = moduleRef.substring(0, hashIndex);\n      }\n    }\n\n    if (pathMeta && pathMeta.extension) {\n      extension = pathMeta.extension;\n      if (moduleRef.endsWith(extension)) {\n        moduleRef = moduleRef.substring(0, moduleRef.length - extension.length);\n      }\n    }\n\n    return { moduleRef, expectedHash, extension };\n  }\n\n  /**\n   * Check if a path is a URL\n   */\n  private isURLPath(path: string): boolean {\n    return this.env.isURL(path);\n  }\n\n  /**\n   * Liberal import syntax support - handles both quoted and unquoted module references\n   * This follows Postel's Law: \"be liberal in what you accept\"\n   */\n  private handleLiberalImportSyntax(pathNodes: ContentNodeArray): ContentNodeArray {\n    // The liberal syntax is actually handled through normal interpolation\n    // When a quoted module reference like \"@local/test\" is encountered,\n    // the interpolation process will try to resolve @local as a variable first,\n    // and if not found, it will reconstruct the full path\n    // This is implemented in the interpolate function, not here\n    return pathNodes;\n  }\n}\n","import * as crypto from 'crypto';\n\n/**\n * Interface for module content with hash information\n */\nexport interface ModuleContent {\n  content: string;\n  hash: string;\n  metadata?: {\n    source: string;\n    timestamp: Date;\n    size: number;\n  };\n}\n\n/**\n * Hash utilities for content-addressed module storage\n */\nexport class HashUtils {\n  /**\n   * Generate SHA-256 hash of content\n   * @param content - The content to hash\n   * @returns 64-character hex string hash\n   */\n  static hash(content: string): string {\n    return crypto.createHash('sha256').update(content).digest('hex');\n  }\n\n  /**\n   * Generate SRI-style integrity hash (sha256-base64)\n   * @param content - The content to hash\n   * @returns SRI-formatted integrity string\n   */\n  static integrity(content: string): string {\n    const hash = crypto.createHash('sha256').update(content).digest('base64');\n    return `sha256-${hash}`;\n  }\n\n  /**\n   * Verify content against a hash\n   * @param content - The content to verify\n   * @param expectedHash - The expected SHA-256 hash (hex)\n   * @returns true if content matches hash\n   */\n  static verify(content: string, expectedHash: string): boolean {\n    const actualHash = this.hash(content);\n    return actualHash === expectedHash;\n  }\n\n  /**\n   * Verify content against SRI integrity string\n   * @param content - The content to verify\n   * @param integrity - The SRI integrity string (e.g., \"sha256-...\")\n   * @returns true if content matches integrity\n   */\n  static verifyIntegrity(content: string, integrity: string): boolean {\n    const actualIntegrity = this.integrity(content);\n    return actualIntegrity === integrity;\n  }\n\n  /**\n   * Get short hash (first n characters)\n   * @param fullHash - The full 64-character hash\n   * @param length - Number of characters (default 8)\n   * @returns Short hash string\n   */\n  static shortHash(fullHash: string, length: number = 8): string {\n    return fullHash.substring(0, length);\n  }\n\n  /**\n   * Expand short hash to full hash by searching cache\n   * @param shortHash - The short hash to expand\n   * @param availableHashes - List of full hashes to search\n   * @returns Full hash if unique match found, null otherwise\n   */\n  static expandHash(shortHash: string, availableHashes: string[]): string | null {\n    const matches = availableHashes.filter(hash => hash.startsWith(shortHash));\n    \n    if (matches.length === 1) {\n      return matches[0];\n    } else if (matches.length === 0) {\n      return null;\n    } else {\n      // Multiple matches - ambiguous\n      throw new Error(`Ambiguous short hash '${shortHash}' matches ${matches.length} hashes`);\n    }\n  }\n\n  /**\n   * Get cache directory path for a hash\n   * Uses first 2 characters as subdirectory for better filesystem performance\n   * @param hash - The full hash\n   * @returns Path components [prefix, rest] for directory structure\n   */\n  static getCachePathComponents(hash: string): { prefix: string; rest: string } {\n    return {\n      prefix: hash.substring(0, 2),\n      rest: hash.substring(2)\n    };\n  }\n\n  /**\n   * Create module content object with hash\n   * @param content - The module content\n   * @param source - The source URL/path\n   * @returns ModuleContent object\n   */\n  static createModuleContent(content: string, source: string): ModuleContent {\n    return {\n      content,\n      hash: this.hash(content),\n      metadata: {\n        source,\n        timestamp: new Date(),\n        size: Buffer.byteLength(content, 'utf8')\n      }\n    };\n  }\n\n  /**\n   * Compare two hashes in constant time to prevent timing attacks\n   * @param hash1 - First hash\n   * @param hash2 - Second hash\n   * @returns true if hashes match\n   */\n  static secureCompare(hash1: string, hash2: string): boolean {\n    if (hash1.length !== hash2.length) {\n      return false;\n    }\n    \n    const buffer1 = Buffer.from(hash1);\n    const buffer2 = Buffer.from(hash2);\n    \n    return crypto.timingSafeEqual(buffer1, buffer2);\n  }\n}","import type { Environment } from '../../env/Environment';\nimport type { ImportResolution } from './ImportPathResolver';\nimport { HashUtils } from '@core/registry/utils/HashUtils';\nimport { checkMlldVersion, formatVersionError } from '@core/utils/version-checker';\nimport { version as currentMlldVersion } from '@core/version';\nimport { MlldError } from '@core/errors';\nimport { logger } from '@core/utils/logger';\nimport * as path from 'path';\n\nexport interface SecurityValidation {\n  approved: boolean;\n  hashValid: boolean;\n  versionCompatible: boolean;\n  circularImportDetected: boolean;\n  errors: string[];\n}\n\n/**\n * Handles all security validation aspects of import processing\n */\nexport class ImportSecurityValidator {\n  constructor(private env: Environment) {}\n\n  /**\n   * Validates import security including circular imports, content hashes, \n   * version compatibility, and import approval\n   */\n  async validateImportSecurity(\n    resolution: ImportResolution,\n    content?: string\n  ): Promise<SecurityValidation> {\n    const validation: SecurityValidation = {\n      approved: true,\n      hashValid: true,\n      versionCompatible: true,\n      circularImportDetected: false,\n      errors: []\n    };\n\n    // Check for circular imports\n    validation.circularImportDetected = this.checkCircularImports(resolution.resolvedPath);\n    if (validation.circularImportDetected) {\n      validation.errors.push(`Circular import detected: ${resolution.resolvedPath}`);\n      return validation;\n    }\n\n    // Validate content hash if expected and content is provided\n    if (resolution.expectedHash && content) {\n      validation.hashValid = this.validateContentHash(\n        content, \n        resolution.expectedHash, \n        resolution.resolvedPath\n      );\n      if (!validation.hashValid) {\n        validation.errors.push(`Hash validation failed for: ${resolution.resolvedPath}`);\n      }\n    }\n\n    return validation;\n  }\n\n  /**\n   * Checks for circular import dependencies\n   */\n  checkCircularImports(resolvedPath: string): boolean {\n    return this.env.isImporting(resolvedPath);\n  }\n\n  /**\n   * Validates content hash against expected hash (supports both full and short hashes)\n   */\n  validateContentHash(content: string, expectedHash: string, resolvedPath: string): boolean {\n    // Skip hash validation in test mode for modules-hash fixture\n    const isTestMode = process.env.MLLD_SKIP_HASH_VALIDATION === 'true';\n    \n    if (isTestMode) {\n      return true;\n    }\n\n    const actualHash = HashUtils.hash(content);\n    const shortActualHash = HashUtils.shortHash(actualHash, expectedHash.length);\n    \n    // Compare with the expected hash (supporting short hashes)\n    if (expectedHash.length < 64) {\n      // Short hash comparison\n      if (shortActualHash !== expectedHash) {\n        throw new Error(\n          `Module hash mismatch for '${resolvedPath}': ` +\n          `expected ${expectedHash}, got ${shortActualHash} (full: ${actualHash})`\n        );\n      }\n    } else {\n      // Full hash comparison\n      if (!HashUtils.secureCompare(actualHash, expectedHash)) {\n        throw new Error(\n          `Module hash mismatch for '${resolvedPath}': ` +\n          `expected ${expectedHash}, got ${actualHash}`\n        );\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Checks mlld version compatibility from frontmatter\n   */\n  checkVersionCompatibility(frontmatterData: Record<string, any>, resolvedPath: string): boolean {\n    const requiredVersion = frontmatterData['mlld-version'] || \n                           frontmatterData['mlldVersion'] ||\n                           frontmatterData['mlld_version'];\n    \n    if (!requiredVersion) {\n      return true; // No version requirement\n    }\n\n    if (process.env.MLLD_DEBUG_VERSION) {\n      logger.debug(`[Version Check] Module requires: ${requiredVersion}, Current: ${currentMlldVersion}`);\n    }\n\n    const versionCheck = checkMlldVersion(requiredVersion);\n    if (!versionCheck.compatible) {\n      const moduleName = frontmatterData.module || \n                        frontmatterData.name || \n                        path.basename(resolvedPath);\n      \n      throw new MlldError(\n        formatVersionError(moduleName, requiredVersion, currentMlldVersion),\n        { \n          code: 'VERSION_MISMATCH', \n          severity: 'error',\n          module: moduleName,\n          requiredVersion,\n          path: resolvedPath\n        }\n      );\n    }\n\n    return true;\n  }\n\n  /**\n   * Requests import approval for URL imports if needed\n   */\n  async requestImportApproval(resolvedPath: string): Promise<boolean> {\n    const isURL = this.env.isURL(resolvedPath);\n    \n    if (isURL) {\n      // The approval process is handled by env.fetchURL with forImport=true\n      // This method exists for explicit approval workflow if needed\n      return true;\n    }\n    \n    return true; // File imports don't need approval\n  }\n\n  /**\n   * Marks the beginning of an import for circular detection\n   */\n  beginImport(resolvedPath: string): void {\n    const isURL = this.env.isURL(resolvedPath);\n    if (isURL) {\n      this.env.beginImport(resolvedPath);\n    }\n  }\n\n  /**\n   * Marks the end of an import for circular detection\n   */\n  endImport(resolvedPath: string): void {\n    const isURL = this.env.isURL(resolvedPath);\n    if (isURL) {\n      this.env.endImport(resolvedPath);\n    }\n  }\n\n  /**\n   * Validates overall module integrity combining all security checks\n   */\n  async validateModuleIntegrity(\n    resolution: ImportResolution,\n    content: string,\n    frontmatterData?: Record<string, any> | null\n  ): Promise<void> {\n    // Check circular imports\n    if (this.checkCircularImports(resolution.resolvedPath)) {\n      throw new Error(`Circular import detected: ${resolution.resolvedPath}`);\n    }\n\n    // Validate content hash if expected\n    if (resolution.expectedHash) {\n      this.validateContentHash(content, resolution.expectedHash, resolution.resolvedPath);\n    }\n\n    // Check version compatibility if frontmatter is provided\n    if (frontmatterData) {\n      this.checkVersionCompatibility(frontmatterData, resolution.resolvedPath);\n    }\n  }\n\n  /**\n   * Validates content security excluding circular import checks\n   * (Used when import tracking is already in progress)\n   */\n  async validateContentSecurity(\n    resolution: ImportResolution,\n    content: string,\n    frontmatterData?: Record<string, any> | null\n  ): Promise<void> {\n    // Validate content hash if expected\n    if (resolution.expectedHash) {\n      this.validateContentHash(content, resolution.expectedHash, resolution.resolvedPath);\n    }\n\n    // Check version compatibility if frontmatter is provided\n    if (frontmatterData) {\n      this.checkVersionCompatibility(frontmatterData, resolution.resolvedPath);\n    }\n  }\n}","import type { SourceLocation } from '@core/types';\n\n/**\n * Collects `/export` declarations encountered while a module evaluates so later\n * import processing can validate and filter the exported variables.\n */\nexport interface ExportManifestEntry {\n  name: string;\n  kind?: 'variable' | 'guard';\n  location?: SourceLocation;\n}\n\nexport class ExportManifest implements Iterable<ExportManifestEntry> {\n  private readonly entries = new Map<string, ExportManifestEntry>();\n\n  add(entries: ExportManifestEntry[]): void {\n    for (const entry of entries) {\n      const name = entry?.name;\n      if (!name) continue;\n      const trimmed = name.trim();\n      if (!trimmed) continue;\n\n      if (!this.entries.has(trimmed)) {\n        this.entries.set(trimmed, { name: trimmed, kind: entry.kind, location: entry.location });\n      } else if (entry.location && !this.entries.get(trimmed)?.location) {\n        const existing = this.entries.get(trimmed)!;\n        this.entries.set(trimmed, { ...existing, location: entry.location });\n      }\n    }\n  }\n\n  hasEntries(): boolean {\n    return this.entries.size > 0;\n  }\n\n  getNames(): string[] {\n    return Array.from(this.entries.keys());\n  }\n\n  getEntries(): ExportManifestEntry[] {\n    return Array.from(this.entries.values());\n  }\n\n  getLocation(name: string): SourceLocation | undefined {\n    return this.entries.get(name)?.location;\n  }\n\n  [Symbol.iterator](): IterableIterator<ExportManifestEntry> {\n    return this.entries.values();\n  }\n\n  toArray(): ExportManifestEntry[] {\n    return this.getEntries();\n  }\n}\n","import type { DirectiveNode } from '@core/types';\nimport type { Environment } from '../../env/Environment';\nimport type { ImportResolution } from './ImportPathResolver';\nimport { ImportSecurityValidator } from './ImportSecurityValidator';\nimport { VariableImporter } from './VariableImporter';\nimport { ExportManifest } from './ExportManifest';\nimport { parse } from '@grammar/parser';\nimport type { TemplateExecutable } from '@core/types/executable';\nimport { interpolate, evaluate } from '../../core/interpreter';\nimport { MlldError, MlldImportError } from '@core/errors';\nimport { logger } from '@core/utils/logger';\nimport * as path from 'path';\nimport { makeSecurityDescriptor, mergeDescriptors, type SecurityDescriptor } from '@core/types/security';\nimport { labelsForPath } from '@core/security/paths';\nimport type { SerializedGuardDefinition } from '../../guards';\nimport type { NeedsDeclaration, WantsTier } from '@core/policy/needs';\nimport type { IFileSystemService } from '@services/fs/IFileSystemService';\nimport { inferMlldMode } from '@core/utils/mode';\n\nexport interface ModuleProcessingResult {\n  moduleObject: Record<string, any>;\n  frontmatter: Record<string, any> | null;\n  childEnvironment: Environment;\n  guardDefinitions: SerializedGuardDefinition[];\n  moduleNeeds?: NeedsDeclaration;\n  moduleWants?: WantsTier[];\n  policyContext?: Record<string, unknown> | null;\n}\n\n/**\n * Handles content reading, parsing, and AST evaluation for imported modules\n */\nexport class ModuleContentProcessor {\n  constructor(\n    private env: Environment,\n    private securityValidator: ImportSecurityValidator,\n    private variableImporter: VariableImporter\n  ) {}\n\n  /**\n   * Process module content from reading through evaluation\n   */\n  async processModuleContent(\n    resolution: ImportResolution,\n    directive: DirectiveNode\n  ): Promise<ModuleProcessingResult> {\n    const { resolvedPath } = resolution;\n    const isURL = resolution.type === 'url';\n\n    // Begin import tracking for security\n    this.securityValidator.beginImport(resolvedPath);\n    const snapshot = this.env.getSecuritySnapshot();\n    const importDescriptor = mergeDescriptors(\n      snapshot\n        ? makeSecurityDescriptor({\n            labels: snapshot.labels,\n            taint: snapshot.taint,\n            sources: snapshot.sources,\n            policyContext: snapshot.policy ? { ...snapshot.policy } : undefined\n          })\n        : makeSecurityDescriptor(),\n      makeSecurityDescriptor({\n        labels: directive.meta?.securityLabels || directive.values?.securityLabels\n      })\n    );\n    const fileDescriptor = !isURL\n      ? makeSecurityDescriptor({\n          taint: ['src:file', ...labelsForPath(resolvedPath)],\n          sources: [resolvedPath]\n        })\n      : undefined;\n    const combinedDescriptor = fileDescriptor\n      ? mergeDescriptors(importDescriptor, fileDescriptor)\n      : importDescriptor;\n    if (combinedDescriptor) {\n      this.env.recordSecurityDescriptor(combinedDescriptor);\n    }\n    try {\n      if (resolution.importType === 'templates') {\n        return await this.processTemplateCollection(resolution, directive);\n      }\n\n      // Disallow importing template files (.att/.mtt). Use /exe ... = template \"path\" instead.\n      const lowerPath = resolvedPath.toLowerCase();\n      if (lowerPath.endsWith('.att') || lowerPath.endsWith('.mtt')) {\n        const { MlldImportError } = await import('@core/errors');\n        // Try to infer a friendly suggested name from the directive\n        let suggestedName = 'template';\n        try {\n          const ns = (directive as any)?.values?.namespace;\n          if (Array.isArray(ns) && ns[0]?.content) suggestedName = ns[0].content;\n          const firstImport = (directive as any)?.values?.imports?.[0];\n          if (firstImport?.alias) suggestedName = firstImport.alias;\n        } catch {}\n        const example = `/exe @${suggestedName}(param1, param2) = template \"${resolvedPath}\"\n/show @${suggestedName}(\"value1\", \"value2\")`;\n        throw new MlldImportError(\n          `Template files cannot be imported: ${resolvedPath}. Use an executable template instead.`,\n          {\n            code: 'TEMPLATE_IMPORT_NOT_ALLOWED',\n            context: {\n              hint: 'Define an /exe that loads the template file and declares parameters.',\n              example\n            },\n            details: { filePath: resolvedPath }\n          }\n        );\n      }\n\n      // Read content from source\n      const content = await this.readContentFromSource(resolution);\n\n      // Cache the source content for error reporting\n      this.env.cacheSource(resolvedPath, content);\n\n      // Validate security (including hash validation, but NOT circular imports since we're tracking now)\n      await this.securityValidator.validateContentSecurity(resolution, content);\n\n      // Parse content based on type and capture processed content\n      const { parsed, processedContent, isPlainText, templateSyntax } = await this.parseContentByType(\n        content,\n        resolvedPath,\n        directive\n      );\n\n      // Check if this is a JSON file (special handling)\n      if (resolvedPath.endsWith('.json')) {\n        return this.processJSONContent(parsed, directive, resolvedPath);\n      }\n\n      // Check if this is plain text content (not mlld)\n      if (isPlainText) {\n        return this.processPlainTextContent(resolvedPath);\n      }\n\n      // Handle raw template files (.att for @var, .mtt for mustache)\n      if (!parsed && templateSyntax) {\n        return this.processRawTemplate(processedContent, templateSyntax, resolvedPath);\n      }\n\n      // Process mlld content\n      return this.processMLLDContent(parsed, processedContent, resolvedPath, isURL);\n    } finally {\n      // End import tracking\n      this.securityValidator.endImport(resolvedPath);\n    }\n  }\n\n  /**\n   * Process module content from resolver (content already fetched)\n   */\n  async processResolverContent(\n    content: string,\n    ref: string,\n    directive: DirectiveNode,\n    contentType?: 'module' | 'data' | 'text',\n    labels?: readonly string[]\n  ): Promise<ModuleProcessingResult> {\n    // Begin import tracking for security\n    this.securityValidator.beginImport(ref);\n    const snapshot = this.env.getSecuritySnapshot();\n    const importDescriptor = mergeDescriptors(\n      snapshot\n        ? makeSecurityDescriptor({\n            labels: snapshot.labels,\n            taint: snapshot.taint,\n            sources: snapshot.sources,\n            policyContext: snapshot.policy ? { ...snapshot.policy } : undefined\n          })\n        : makeSecurityDescriptor(),\n      makeSecurityDescriptor({\n        labels: directive.meta?.securityLabels || directive.values?.securityLabels\n      })\n    );\n    const fileDescriptor =\n      ref && !this.isUrlLike(ref) && !ref.startsWith('@')\n        ? makeSecurityDescriptor({\n            taint: ['src:file', ...labelsForPath(ref)],\n            sources: [ref]\n          })\n        : undefined;\n    const combinedDescriptor = fileDescriptor\n      ? mergeDescriptors(importDescriptor, fileDescriptor)\n      : importDescriptor;\n    if (combinedDescriptor) {\n      this.env.recordSecurityDescriptor(combinedDescriptor);\n    }\n    try {\n      // Disallow importing template files (.att/.mtt). Use /exe ... = template \"path\" instead.\n      const lowerRef = ref.toLowerCase();\n      if (lowerRef.endsWith('.att') || lowerRef.endsWith('.mtt')) {\n        const { MlldImportError } = await import('@core/errors');\n        let suggestedName = 'template';\n        try {\n          const ns = (directive as any)?.values?.namespace;\n          if (Array.isArray(ns) && ns[0]?.content) suggestedName = ns[0].content;\n          const firstImport = (directive as any)?.values?.imports?.[0];\n          if (firstImport?.alias) suggestedName = firstImport.alias;\n        } catch {}\n        const example = `/exe @${suggestedName}(param1, param2) = template \"${ref}\"\n/show @${suggestedName}(\"value1\", \"value2\")`;\n        throw new MlldImportError(\n          `Template files cannot be imported: ${ref}. Use an executable template instead.`,\n          {\n            code: 'TEMPLATE_IMPORT_NOT_ALLOWED',\n            context: {\n              hint: 'Define an /exe that loads the template file and declares parameters.',\n              example\n            },\n            details: { filePath: ref }\n          }\n        );\n      }\n\n      if (process.env.MLLD_DEBUG === 'true') {\n        console.log(`[ModuleContentProcessor] Processing resolver content for: ${ref}`);\n        console.log(`[ModuleContentProcessor] Content length: ${content.length}`);\n        console.log(`[ModuleContentProcessor] Content preview: ${content.substring(0, 200)}`);\n      }\n\n      // Cache the source content for error reporting\n      this.env.cacheSource(ref, content);\n\n      // Check if this is a dynamic module (has 'src:dynamic' label)\n      const isDynamicModule = labels?.includes('src:dynamic') ?? false;\n\n      // Parse content based on type\n      const { parsed, processedContent, isPlainText, templateSyntax } = await this.parseContentByType(\n        content,\n        ref,\n        directive,\n        contentType,\n        isDynamicModule\n      );\n\n      // Check if this is a JSON file (special handling)\n      if (ref.endsWith('.json')) {\n        return this.processJSONContent(parsed, directive, ref);\n      }\n\n      // Check if this is plain text content (not mlld)\n      if (isPlainText) {\n        return this.processPlainTextContent(ref);\n      }\n\n      // Handle raw template files (.att for @var, .mtt for mustache)\n      if (!parsed && templateSyntax) {\n        return this.processRawTemplate(processedContent, templateSyntax, ref);\n      }\n\n      // Process mlld content\n      const result = await this.processMLLDContent(parsed, processedContent, ref, false);\n      \n      if (process.env.MLLD_DEBUG === 'true') {\n        console.log(`[ModuleContentProcessor] Module object keys: ${Object.keys(result.moduleObject).join(', ')}`);\n        console.log(`[ModuleContentProcessor] Has frontmatter: ${result.frontmatter !== null}`);\n        console.log(`[ModuleContentProcessor] Child env vars: ${result.childEnvironment.getCurrentVariables().size}`);\n        console.log(`[ModuleContentProcessor] Child env var names: ${Array.from(result.childEnvironment.getCurrentVariables().keys()).join(', ')}`);\n      }\n      \n      return result;\n    } finally {\n      // End import tracking\n      this.securityValidator.endImport(ref);\n    }\n  }\n\n  private async processTemplateCollection(\n    resolution: ImportResolution,\n    directive: DirectiveNode\n  ): Promise<ModuleProcessingResult> {\n    const fsService = this.env.getFileSystemService?.();\n    if (!fsService || typeof fsService.readdir !== 'function') {\n      throw new MlldImportError('Templates import requires filesystem access', {\n        code: 'TEMPLATE_IMPORT_FS_UNAVAILABLE',\n        details: { path: resolution.resolvedPath }\n      });\n    }\n\n    const paramNames = this.extractParamNames((directive as any)?.values?.templateParams);\n    if (paramNames.length === 0) {\n      throw new MlldImportError(\n        'Templates import requires parameters. Use: /import templates from \"dir\" as @name(param1, param2)',\n        {\n          code: 'TEMPLATE_IMPORT_MISSING_PARAMS',\n          details: { path: resolution.resolvedPath }\n        }\n      );\n    }\n\n    const baseDir = resolution.resolvedPath;\n    const isDir = await fsService.isDirectory(baseDir);\n    if (!isDir) {\n      throw new MlldImportError(`Templates import must target a directory: ${baseDir}`, {\n        code: 'TEMPLATE_IMPORT_NOT_DIRECTORY',\n        details: { path: baseDir }\n      });\n    }\n\n    const moduleObject: Record<string, any> = {};\n    await this.walkTemplateDirectory(fsService, baseDir, moduleObject, paramNames, baseDir);\n\n    if (Object.keys(moduleObject).length === 0) {\n      throw new MlldImportError(`No templates found under ${baseDir}`, {\n        code: 'TEMPLATE_IMPORT_EMPTY',\n        details: { path: baseDir }\n      });\n    }\n\n    const childEnv = this.env.createChild(baseDir);\n    childEnv.setCurrentFilePath(baseDir);\n\n    return {\n      moduleObject,\n      frontmatter: null,\n      childEnvironment: childEnv,\n      guardDefinitions: []\n    };\n  }\n\n  private async walkTemplateDirectory(\n    fsService: IFileSystemService,\n    dir: string,\n    target: Record<string, any>,\n    paramNames: string[],\n    root: string\n  ): Promise<void> {\n    const entries = await fsService.readdir(dir);\n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry);\n      const stat = await fsService\n        .stat(fullPath)\n        .catch(() => ({ isDirectory: () => false, isFile: () => false }));\n\n      if (stat.isDirectory()) {\n        const key = this.sanitizeKey(entry);\n        if (key in target) {\n          throw new MlldImportError(\n            `Duplicate template group '${key}' in ${dir}`,\n            {\n              code: 'TEMPLATE_IMPORT_DUPLICATE_GROUP',\n              details: { path: fullPath }\n            }\n          );\n        }\n        const childGroup: Record<string, any> = {};\n        await this.walkTemplateDirectory(fsService, fullPath, childGroup, paramNames, root);\n        if (Object.keys(childGroup).length > 0) {\n          target[key] = childGroup;\n        }\n      } else if (stat.isFile()) {\n        const lower = entry.toLowerCase();\n        if (!lower.endsWith('.att') && !lower.endsWith('.mtt')) {\n          continue;\n        }\n        const key = this.sanitizeKey(entry);\n        if (key in target) {\n          throw new MlldImportError(\n            `Duplicate template name '${key}' in ${dir}`,\n            {\n              code: 'TEMPLATE_IMPORT_DUPLICATE_TEMPLATE',\n              details: { path: fullPath }\n            }\n          );\n        }\n        const relativePath = path.relative(root, fullPath) || entry;\n        target[key] = await this.buildTemplateExecutable(fullPath, paramNames, relativePath);\n      }\n    }\n  }\n\n  private async buildTemplateExecutable(\n    filePath: string,\n    paramNames: string[],\n    displayPath: string\n  ): Promise<Record<string, unknown>> {\n    const ext = path.extname(filePath).toLowerCase();\n    const fileContent = await this.env.readFile(filePath);\n    const { parseSync } = await import('@grammar/parser');\n    const startRule = ext === '.mtt' ? 'TemplateBodyMtt' : 'TemplateBodyAtt';\n    let templateNodes: any[];\n    try {\n      templateNodes = parseSync(fileContent, { startRule });\n    } catch (err: any) {\n      let normalized = fileContent;\n      if (ext === '.mtt') {\n        normalized = normalized.replace(/{{\\s*([A-Za-z_][\\w\\.]*)\\s*}}/g, '@$1');\n      }\n      templateNodes = this.buildTemplateAst(normalized);\n    }\n\n    this.validateTemplateParameters(templateNodes, paramNames, displayPath);\n\n    const execDef: TemplateExecutable = {\n      type: 'template',\n      template: templateNodes,\n      paramNames,\n      sourceDirective: 'exec'\n    };\n\n    return {\n      __executable: true,\n      value: execDef,\n      executableDef: execDef,\n      internal: { executableDef: execDef }\n    };\n  }\n\n  private validateTemplateParameters(\n    templateNodes: any[],\n    paramNames: string[],\n    templatePath: string\n  ): void {\n    const references = new Set<string>();\n    this.collectTemplateReferences(templateNodes, references);\n    const allowed = new Set<string>([\n      ...paramNames,\n      'mx',\n      'pipeline',\n      'p',\n      'state',\n      'payload',\n      'input'\n    ]);\n    const invalid = Array.from(references).filter(ref => !allowed.has(ref));\n    if (invalid.length > 0) {\n      throw new MlldImportError(\n        `Template '${templatePath}' references undeclared variables: ${invalid.join(', ')}`,\n        {\n          code: 'TEMPLATE_IMPORT_PARAM_MISMATCH',\n          details: {\n            template: templatePath,\n            allowed: paramNames,\n            invalid\n          }\n        }\n      );\n    }\n  }\n\n  private collectTemplateReferences(node: any, refs: Set<string>): void {\n    if (!node) return;\n    if (Array.isArray(node)) {\n      node.forEach(child => this.collectTemplateReferences(child, refs));\n      return;\n    }\n    if (typeof node !== 'object') {\n      return;\n    }\n\n    if (node.type === 'VariableReference' && typeof node.identifier === 'string') {\n      refs.add(node.identifier);\n    }\n    if (\n      node.type === 'VariableReferenceWithTail' &&\n      node.variable &&\n      typeof node.variable.identifier === 'string'\n    ) {\n      refs.add(node.variable.identifier);\n    }\n\n    for (const value of Object.values(node)) {\n      if (value && typeof value === 'object') {\n        this.collectTemplateReferences(value, refs);\n      }\n    }\n  }\n\n  private sanitizeKey(name: string): string {\n    const withoutExt = name.replace(/\\.[^.]+$/, '');\n    // Preserve hyphens in file names - they're valid in mlld identifiers\n    const sanitized = withoutExt.replace(/[^a-zA-Z0-9_-]/g, '_');\n    return sanitized.length > 0 ? sanitized : 'template';\n  }\n\n  private extractParamNames(params: any[] | undefined): string[] {\n    if (!params || params.length === 0) {\n      return [];\n    }\n    return params\n      .map(param => {\n        if (typeof param === 'string') {\n          return param;\n        }\n        if (param?.type === 'Parameter' && param.name) {\n          return param.name;\n        }\n        if (param?.identifier) {\n          return param.identifier;\n        }\n        return '';\n      })\n      .filter(Boolean);\n  }\n\n  /**\n   * Read content from file or URL\n   */\n  private async readContentFromSource(resolution: ImportResolution): Promise<string> {\n    const { resolvedPath, type, importType, cacheDurationMs } = resolution;\n    try {\n      if (type === 'url') {\n        return await this.env.fetchURL(resolvedPath, {\n          forImport: true,\n          importType: importType,\n          cacheDurationMs\n        });\n      }\n      return await this.env.readFile(resolvedPath);\n    } catch (error) {\n      throw new Error(`Failed to read imported file '${resolvedPath}': ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  /**\n   * Parse content by type (JSON vs mlld vs text)\n   */\n  private async parseContentByType(\n    content: string,\n    resolvedPath: string,\n    directive: DirectiveNode,\n    contentType?: 'module' | 'data' | 'text',\n    isDynamicModule?: boolean\n  ): Promise<{ parsed: any | null; processedContent: string; isPlainText: boolean; templateSyntax?: 'tripleColon' | 'doubleColon' }> {\n    // Check if this is a JSON file\n    if (resolvedPath.endsWith('.json')) {\n      try {\n        return { parsed: JSON.parse(content), processedContent: content, isPlainText: false };\n      } catch (error) {\n        throw new Error(`Failed to parse JSON file '${resolvedPath}': ${error instanceof Error ? error.message : String(error)}`);\n      }\n    }\n\n    // New: explicit template file handling\n    // .att = \"at template\" using @var references\n    if (resolvedPath.endsWith('.att')) {\n      return { parsed: null, processedContent: content, isPlainText: false, templateSyntax: 'doubleColon' };\n    }\n    // .mtt = mustache-template using {{var}} references\n    if (resolvedPath.endsWith('.mtt')) {\n      return { parsed: null, processedContent: content, isPlainText: false, templateSyntax: 'tripleColon' };\n    }\n\n    const hasModuleExtension =\n      resolvedPath.endsWith('.mld') ||\n      resolvedPath.endsWith('.mlld') ||\n      resolvedPath.endsWith('.mld.md') ||\n      resolvedPath.endsWith('.mlld.md') ||\n      resolvedPath.endsWith('.md');\n    const forceModuleParse = contentType === 'module' || resolvedPath.startsWith('@');\n\n    // Only parse as mlld when it is a module (by hint or extension)\n    if (!forceModuleParse && !hasModuleExtension) {\n      // Return a marker indicating this is plain text content\n      return { parsed: { isPlainText: true }, processedContent: content, isPlainText: true };\n    }\n\n    // Handle section extraction if specified\n    let processedContent = content;\n    const sectionNodes = directive.values?.section;\n    if (sectionNodes && Array.isArray(sectionNodes)) {\n      const descriptors: SecurityDescriptor[] = [];\n      const section = await interpolate(sectionNodes, this.env, undefined, {\n        collectSecurityDescriptor: descriptor => {\n          if (descriptor) {\n            descriptors.push(descriptor);\n          }\n        }\n      });\n      const merged =\n        descriptors.length === 1\n          ? descriptors[0]\n          : descriptors.length > 1\n            ? this.env.mergeSecurityDescriptors(...descriptors)\n            : undefined;\n      if (merged) {\n        this.env.recordSecurityDescriptor(merged);\n      }\n      if (section) {\n        processedContent = this.extractSectionContent(content, section);\n      }\n    }\n\n    // Removed: triple-colon detection for .mld/.mld.md imports.\n    // External template detection now uses .att and .mtt extensions.\n\n    // Infer mode from the imported file's extension\n    // Virtual filesystems (tests) use markdown mode for backward compatibility\n    // Real filesystems use extension-based mode inference\n    const fsService = this.env.getFileSystemService();\n    const hasIsVirtual = typeof fsService?.isVirtual === 'function';\n    const isVirtualFS = hasIsVirtual ? fsService.isVirtual() : false;\n    const mode = isDynamicModule\n      ? this.env.getDynamicModuleMode()\n      : isVirtualFS\n        ? 'markdown'\n        : inferMlldMode(resolvedPath);\n\n    // Parse the imported mlld content with the inferred mode\n    const parseResult = await parse(processedContent, { mode });\n\n    // Check if parsing succeeded\n    if (!parseResult.success) {\n      this.handleParseError(parseResult.error, resolvedPath);\n    }\n\n    return { parsed: parseResult, processedContent, isPlainText: false };\n  }\n\n  /**\n   * Process plain text content (non-mlld files like .txt)\n   */\n  private async processPlainTextContent(\n    resolvedPath: string\n  ): Promise<ModuleProcessingResult> {\n    // Plain text files create an empty namespace\n    const moduleObject: Record<string, any> = {};\n\n    // Create a dummy child environment for consistency\n    const childEnv = this.env.createChild(path.dirname(resolvedPath));\n    childEnv.setCurrentFilePath(resolvedPath);\n\n    return {\n      moduleObject,\n      frontmatter: null,\n      childEnvironment: childEnv,\n      guardDefinitions: []\n    };\n  }\n\n  /**\n   * Process raw template content without parsing\n   */\n  private async processRawTemplate(\n    content: string,\n    templateSyntax: 'doubleColon' | 'tripleColon',\n    resolvedPath: string\n  ): Promise<ModuleProcessingResult> {\n    let finalContent = content;\n    let finalSyntax: 'doubleColon' | 'tripleColon' = templateSyntax;\n    if (templateSyntax === 'tripleColon') {\n      // Convert {{var}} to @var for our internal template AST\n      finalContent = content.replace(/{{\\s*([\\w\\.]+)\\s*}}/g, '@$1');\n      finalSyntax = 'doubleColon';\n    }\n\n    const moduleObject: Record<string, any> = {\n      default: {\n        __template: true,\n        content: finalContent,\n        templateSyntax: finalSyntax,\n        templateAst: this.buildTemplateAst(finalContent)\n      }\n    };\n\n    const childEnv = this.env.createChild(path.dirname(resolvedPath));\n    childEnv.setCurrentFilePath(resolvedPath);\n\n    return {\n      moduleObject,\n      frontmatter: null,\n      childEnvironment: childEnv,\n      guardDefinitions: []\n    };\n  }\n\n  /**\n   * Process JSON content into module format\n   */\n  private async processJSONContent(\n    jsonData: any,\n    directive: DirectiveNode,\n    resolvedPath: string\n  ): Promise<ModuleProcessingResult> {\n    let moduleObject: Record<string, any> = {};\n\n    // Convert JSON properties to module exports\n    if (typeof jsonData === 'object' && jsonData !== null && !Array.isArray(jsonData)) {\n      moduleObject = jsonData;\n    } else {\n      // Non-object JSON (array, string, number, etc.) - store as 'content'\n      moduleObject = { content: jsonData };\n    }\n\n    // Create a dummy child environment for consistency\n    const childEnv = this.env.createChild(path.dirname(resolvedPath));\n    childEnv.setCurrentFilePath(resolvedPath);\n\n    return {\n      moduleObject,\n      frontmatter: null,\n      childEnvironment: childEnv,\n      guardDefinitions: []\n    };\n  }\n\n  /**\n   * Process mlld content through full AST evaluation\n   */\n  private async processMLLDContent(\n    parseResult: any,\n    sourceContent: string,\n    resolvedPath: string,\n    isURL: boolean\n  ): Promise<ModuleProcessingResult> {\n    const ast = parseResult.ast;\n\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log(`[processMLLDContent] Processing ${resolvedPath}:`, {\n        astLength: ast.length,\n        astTypes: ast.slice(0, 10).map((n: any) => `${n.type}${n.kind ? ':' + n.kind : ''}`)\n      });\n    }\n\n    // Extract and validate frontmatter\n    const frontmatterData = await this.extractAndValidateFrontmatter(ast, resolvedPath);\n\n    // Create child environment for evaluation\n    const childEnv = this.createChildEnvironment(resolvedPath, isURL);\n\n    // Set frontmatter on child environment so @fm is available during evaluation\n    if (frontmatterData) {\n      childEnv.setFrontmatter(frontmatterData);\n    }\n\n    if (this.containsExportDirective(ast)) {\n      // Seed the child environment with an empty manifest so subsequent\n      // /export directives can accumulate entries during evaluation.\n      childEnv.setExportManifest(new ExportManifest());\n    } else {\n      // Use `null` to signal the auto-export fallback (no explicit manifest).\n      childEnv.setExportManifest(null);\n    }\n\n    // Evaluate AST in child environment\n    const evalResult = await this.evaluateInChildEnvironment(ast, childEnv, resolvedPath);\n\n    // Process module exports\n    const childVars = childEnv.getCurrentVariables();\n    \n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log(`[processMLLDContent] After evaluation:`, {\n        childVarsSize: childVars.size,\n        childVarNames: Array.from(childVars.keys()),\n        evalResult: evalResult?.value ? 'has value' : 'no value'\n      });\n    }\n    const exportManifest = childEnv.getExportManifest();\n    const { moduleObject, frontmatter, guards } = this.variableImporter.processModuleExports(\n      childVars,\n      { frontmatter: frontmatterData },\n      undefined,\n      exportManifest,\n      childEnv\n    );\n\n    // Add __meta__ property with frontmatter if available\n    if (frontmatter) {\n      moduleObject.__meta__ = frontmatter;\n    }\n\n    // If no variables were exported, treat the entire file as a template\n    if (Object.keys(moduleObject).length === 0 && (resolvedPath.endsWith('.mld') || resolvedPath.endsWith('.mld.md'))) {\n      // Only wrap as template if the file has substantive content (not just comments/whitespace)\n      const hasSubstantive = this.hasSubstantiveContent(sourceContent);\n      if (!hasSubstantive) {\n        const moduleNeeds = childEnv.getModuleNeeds();\n        const moduleWants = childEnv.getModuleWants();\n        const policyContext = childEnv.getPolicyContext() ?? null;\n        return {\n          moduleObject,\n          frontmatter,\n          childEnvironment: childEnv,\n          guardDefinitions: guards,\n          moduleNeeds,\n          moduleWants,\n          policyContext\n        };\n      }\n      let templateSyntax: 'doubleColon' | 'tripleColon' = 'doubleColon';\n      let templateContent = sourceContent;\n      const trimmedSource = sourceContent.trim();\n      if (trimmedSource.startsWith(':::')) {\n        templateSyntax = 'tripleColon';\n        templateContent = trimmedSource.slice(3).trimStart();\n        if (templateContent.endsWith(':::')) {\n          templateContent = templateContent.slice(0, -3).trimEnd();\n        }\n      }\n\n      moduleObject.default = {\n        __template: true,\n        content: templateContent,\n        templateSyntax,\n        templateAst: this.buildTemplateAst(templateContent)\n      };\n    }\n\n    const moduleNeeds = childEnv.getModuleNeeds();\n    const moduleWants = childEnv.getModuleWants();\n    const policyContext = childEnv.getPolicyContext() ?? null;\n\n    return {\n      moduleObject,\n      frontmatter,\n      childEnvironment: childEnv,\n      guardDefinitions: guards,\n      moduleNeeds,\n      moduleWants,\n      policyContext\n    };\n  }\n\n  /**\n   * Determine if content has substantive (non-comment, non-whitespace) text\n   */\n  private hasSubstantiveContent(content: string): boolean {\n    const lines = content.split('\\n');\n    const filtered = lines.filter(l => !/^\\s*(>>|<<)/.test(l) && l.trim() !== '');\n    return filtered.join('').trim().length > 0;\n  }\n\n  /**\n   * Extract section content from markdown\n   */\n  private extractSectionContent(content: string, sectionName: string): string {\n    const lines = content.split('\\n');\n    const sectionRegex = new RegExp(`^#+\\\\s+${sectionName}\\\\s*$`, 'i');\n    \n    let inSection = false;\n    let sectionLevel = 0;\n    const sectionLines: string[] = [];\n    \n    for (const line of lines) {\n      if (!inSection && sectionRegex.test(line)) {\n        inSection = true;\n        sectionLevel = line.match(/^#+/)?.[0].length || 0;\n        continue;\n      }\n      \n      if (inSection) {\n        const headerMatch = line.match(/^(#+)\\\\s+/);\n        if (headerMatch && headerMatch[1].length <= sectionLevel) {\n          break;\n        }\n        \n        sectionLines.push(line);\n      }\n    }\n    \n    return sectionLines.join('\\n').trim();\n  }\n\n  /**\n   * Build a simple template AST from content with @var placeholders\n   */\n  private buildTemplateAst(content: string): any[] {\n    const ast: any[] = [];\n    const regex = /@([A-Za-z_][\\w\\.]*)/g;\n    let lastIndex = 0;\n    let match: RegExpExecArray | null;\n    while ((match = regex.exec(content)) !== null) {\n      if (match.index > lastIndex) {\n        ast.push({ type: 'Text', content: content.slice(lastIndex, match.index) });\n      }\n      ast.push({ type: 'VariableReference', identifier: match[1] });\n      lastIndex = match.index + match[0].length;\n    }\n    if (lastIndex < content.length) {\n      ast.push({ type: 'Text', content: content.slice(lastIndex) });\n    }\n    return ast;\n  }\n\n  /**\n   * Handle parse errors with detailed context\n   */\n  private handleParseError(parseError: any, resolvedPath: string): never {\n    // Create an error that preserves the import context\n    const errorMessage = parseError && 'location' in parseError\n      ? `Syntax error in imported file '${resolvedPath}' at line ${parseError.location?.start?.line || '?'}: ${parseError.message || 'Unknown parse error'}`\n      : `Failed to parse imported file '${resolvedPath}': ${parseError?.message || 'Unknown parse error'}`;\n    \n    const importError = new Error(errorMessage);\n    \n    // Add parse error details to the error for trace enhancement\n    (importError as any).importParseError = {\n      file: path.basename(resolvedPath, '.mld'),\n      line: parseError?.location?.start?.line || '?',\n      message: parseError?.message || 'Unknown parse error'\n    };\n    \n    // Preserve the current trace context - the import directive is already on the stack\n    // The error will be caught by evaluateDirective and enhanced with the trace\n    throw importError;\n  }\n\n  /**\n   * Extract and validate frontmatter from AST\n   */\n  private async extractAndValidateFrontmatter(\n    ast: any[], \n    resolvedPath: string\n  ): Promise<Record<string, any> | null> {\n    let frontmatterData: Record<string, any> | null = null;\n    \n    if (ast.length > 0 && ast[0].type === 'Frontmatter') {\n      const { parseFrontmatter } = await import('../../utils/frontmatter-parser');\n      const frontmatterNode = ast[0] as any;\n      frontmatterData = parseFrontmatter(frontmatterNode.content);\n      \n      // Check mlld version compatibility using security validator\n      this.securityValidator.checkVersionCompatibility(frontmatterData, resolvedPath);\n    }\n    \n    return frontmatterData;\n  }\n\n  /**\n   * Create child environment with proper path configuration\n   */\n  private createChildEnvironment(resolvedPath: string, isURL: boolean): Environment {\n    // For URLs, use the current directory as basePath since URLs don't have directories\n    const importDir = isURL ? this.env.getBasePath() : path.dirname(resolvedPath);\n    const childEnv = this.env.createChild(importDir);\n\n    // Set the current file path for the imported file (for error reporting)\n    childEnv.setCurrentFilePath(resolvedPath);\n\n    // Mark as module-isolated so imports within this module don't conflict\n    // with variables in the parent scope. See mlld-xxx for the bug report.\n    childEnv.setModuleIsolated(true);\n\n    return childEnv;\n  }\n\n  private containsExportDirective(ast: any[]): boolean {\n    return ast.some((node) => node?.type === 'Directive' && node.kind === 'export');\n  }\n\n  /**\n   * Evaluate AST in child environment with error handling\n   */\n  private async evaluateInChildEnvironment(\n    ast: any[],\n    childEnv: Environment,\n    resolvedPath: string\n  ): Promise<any> {\n    // Set the importing flag to prevent directive side effects\n    childEnv.setImporting(true);\n\n    try {\n      // Pass isExpression: true to prevent markdown content from being emitted as effects\n      // Imports should only process directives and create variables, not emit document content\n      return await evaluate(ast, childEnv, { isExpression: true });\n    } catch (error) {\n      throw new Error(\n        `Error evaluating imported file '${resolvedPath}': ${error instanceof Error ? error.message : String(error)}`\n      );\n    } finally {\n      // Always clear the importing flag, even if evaluation fails\n      childEnv.setImporting(false);\n    }\n  }\n\n  private isUrlLike(candidate: string): boolean {\n    return /^https?:\\/\\//i.test(candidate);\n  }\n}\n","import * as fs from 'fs';\nimport type { Variable, ExecutableVariable } from '@core/types/variable';\nimport { logger } from '@core/utils/logger';\n\n/**\n * Handles complex object variable reference resolution for imported modules\n */\nexport class ObjectReferenceResolver {\n  /**\n   * Recursively resolve variable references in nested objects\n   * This handles cases like { ask: @claude_ask } where @claude_ask needs to be resolved\n   */\n  resolveObjectReferences(\n    value: any,\n    variableMap: Map<string, Variable>,\n    options?: { resolveStrings?: boolean }\n  ): any {\n    const resolveStrings = options?.resolveStrings !== false;\n    const stringRefPattern = /^@[A-Za-z0-9_.-]+$/;\n    \n    if (value === null || value === undefined) {\n      return value;\n    }\n    \n    if (Array.isArray(value)) {\n      return value.map(item => this.resolveObjectReferences(item, variableMap, options));\n    }\n    \n    // Check if this is a VariableReference AST node\n    if (typeof value === 'object' && value.type === 'VariableReference' && value.identifier) {\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        console.error('[ObjectReferenceResolver] Found VariableReference AST node:', {\n          identifier: value.identifier,\n          hasFields: !!(value as any).fields,\n          fields: (value as any).fields\n        });\n      }\n      return this.resolveVariableReference(value.identifier, variableMap, (value as any).fields);\n    }\n    \n    if (typeof value === 'object') {\n      // Handle AST object nodes with type and properties/entries\n      if (value.type === 'object' && (value as any).properties) {\n        return this.resolveASTObjectNode(value, variableMap, options);\n      }\n      if (value.type === 'object' && Array.isArray((value as any).entries)) {\n        return this.resolveASTObjectNode(value, variableMap, options);\n      }\n      \n      // Handle regular objects\n      return this.resolveNestedStructures(value, variableMap, options);\n    }\n    \n    // Check if this is a variable reference string (starts with @)\n    if (typeof value === 'string' && resolveStrings && stringRefPattern.test(value)) {\n      const varName = value.substring(1); // Remove @ prefix\n      const referencedVar = variableMap.get(varName);\n\n      if (process.env.DEBUG_EXEC) {\n        logger.debug('resolveObjectReferences looking for variable:', {\n          originalValue: value,\n          varName,\n          found: !!referencedVar,\n          referencedVarType: referencedVar?.type,\n          availableVars: Array.from(variableMap.keys())\n        });\n      }\n\n      if (referencedVar) {\n        return this.resolveExecutableReference(referencedVar);\n      }\n\n      // String looked like a variable but no binding exists; treat as literal\n      return value;\n    }\n    \n    return value;\n  }\n\n  /**\n   * Resolve a single variable reference by name, optionally applying field access\n   */\n  private resolveVariableReference(varName: string, variableMap: Map<string, Variable>, fields?: any[]): any {\n    const referencedVar = variableMap.get(varName);\n\n    if (referencedVar) {\n      let result = this.resolveExecutableReference(referencedVar);\n\n      // Apply field access if present (e.g., @fm.id -> access 'id' field on frontmatter)\n      if (fields && fields.length > 0 && result && typeof result === 'object') {\n        for (const field of fields) {\n          if (field.type === 'field' && typeof field.value === 'string') {\n            if (result && typeof result === 'object' && field.value in result) {\n              result = result[field.value];\n            } else {\n              // Field not found - return undefined to match normal field access behavior\n              return undefined;\n            }\n          } else if (field.type === 'bracketAccess') {\n            const key = field.value;\n            if (result && typeof result === 'object' && key in result) {\n              result = result[key];\n            } else if (Array.isArray(result) && typeof key === 'number') {\n              result = result[key];\n            } else {\n              return undefined;\n            }\n          }\n        }\n      }\n\n      // If the result is an object that might contain more AST nodes, recursively resolve it\n      if (result && typeof result === 'object' && !result.__executable && !Array.isArray(result) && !(result as any).__arraySnapshot) {\n        return this.resolveObjectReferences(result, variableMap);\n      }\n\n      return result;\n    } else {\n      if (process.env.DEBUG_EXEC) {\n        logger.debug('VariableReference AST node not found during import resolution:', varName);\n      }\n      throw new Error(`Variable reference @${varName} not found during import`);\n    }\n  }\n\n  /**\n   * Handle executable variable references with special serialization format\n   */\n  private resolveExecutableReference(referencedVar: Variable): any {\n    // For executables, we need to export them with the proper structure\n    if (referencedVar.type === 'executable') {\n      const execVar = referencedVar as ExecutableVariable;\n      \n      // Serialize shadow environments if present (Maps don't serialize to JSON)\n      let serializedCtx = { ...execVar.mx };\n      let serializedInternal = { ...execVar.internal };\n\n      if (execVar.internal?.capturedShadowEnvs) {\n        serializedInternal = {\n          ...serializedInternal,\n          capturedShadowEnvs: this.serializeShadowEnvs(execVar.internal.capturedShadowEnvs)\n        };\n      }\n      // Serialize module environment if present\n      if (execVar.internal?.capturedModuleEnv) {\n        serializedInternal = {\n          ...serializedInternal,\n          capturedModuleEnv: this.serializeModuleEnv(execVar.internal.capturedModuleEnv)\n        };\n      }\n\n      const result = {\n        __executable: true,\n        value: execVar.value,\n        paramNames: execVar.paramNames,\n        executableDef: execVar.internal?.executableDef,\n        mx: serializedCtx,\n        internal: serializedInternal\n      };\n      return result;\n    } else {\n      if (referencedVar.type === 'array') {\n        return {\n          __arraySnapshot: true,\n          value: referencedVar.value,\n          mx: referencedVar.mx,\n          internal: referencedVar.internal,\n          isComplex: (referencedVar as any).isComplex === true,\n          name: referencedVar.name\n        };\n      }\n      // For other variable types, return the value directly\n      return referencedVar.value;\n    }\n  }\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   */\n  private serializeShadowEnvs(envs: any): 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   * 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: Delegate to VariableImporter to ensure consistent serialization\n   */\n  private serializeModuleEnv(moduleEnv: Map<string, Variable>): any {\n    // Use a simpler approach: serialize each variable individually using the same logic as resolveExecutableReference\n    const result: Record<string, any> = {};\n    for (const [name, variable] of moduleEnv) {\n      if (variable.type === 'executable') {\n        const execVar = variable as ExecutableVariable;\n        let serializedCtx = { ...execVar.mx };\n        let serializedInternal = { ...execVar.internal };\n\n        if (serializedInternal.capturedShadowEnvs) {\n          serializedInternal = {\n            ...serializedInternal,\n            capturedShadowEnvs: this.serializeShadowEnvs(serializedInternal.capturedShadowEnvs)\n          };\n        }\n        // Skip capturedModuleEnv only for items IN the module env to avoid recursion\n        delete serializedInternal.capturedModuleEnv;\n\n        result[name] = {\n          __executable: true,\n          value: execVar.value,\n          paramNames: execVar.paramNames,\n          executableDef: execVar.internal?.executableDef,\n          mx: serializedCtx,\n          internal: serializedInternal\n        };\n      } else {\n        // For other variables, export the value directly\n        result[name] = variable.value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Handle AST object nodes with type and properties\n   */\n  private resolveASTObjectNode(value: any, variableMap: Map<string, Variable>, options?: { resolveStrings?: boolean }): any {\n    const resolved: Record<string, any> = {};\n\n    // New entries format (supports spreads)\n    if (Array.isArray(value.entries) && value.entries.length > 0) {\n      for (const entry of value.entries) {\n        if (entry.type === 'pair') {\n          resolved[entry.key] = this.resolveObjectReferences(entry.value, variableMap, options);\n        } else if (entry.type === 'spread') {\n          for (const spreadNode of entry.value || []) {\n            const spreadValue = this.resolveObjectReferences(spreadNode, variableMap, options);\n            if (spreadValue && typeof spreadValue === 'object' && !Array.isArray(spreadValue)) {\n              Object.assign(resolved, spreadValue);\n            } else {\n              throw new Error('Cannot spread non-object value during import resolution');\n            }\n          }\n        }\n      }\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        console.error('[ObjectReferenceResolver] resolved entries object', {\n          keys: Object.keys(resolved),\n          hasEntries: true\n        });\n        try {\n          fs.appendFileSync(\n            '/tmp/mlld-debug.log',\n            JSON.stringify({\n              source: 'ObjectReferenceResolver',\n              keys: Object.keys(resolved),\n              hasEntries: true\n            }) + '\\n'\n          );\n        } catch {}\n      }\n      return resolved;\n    }\n\n    // Legacy properties format\n    if (value.properties) {\n      for (const [key, val] of Object.entries(value.properties)) {\n        resolved[key] = this.resolveObjectReferences(val, variableMap, options);\n      }\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        console.error('[ObjectReferenceResolver] resolved properties object', {\n          keys: Object.keys(resolved),\n          hasProperties: true\n        });\n        try {\n          fs.appendFileSync(\n            '/tmp/mlld-debug.log',\n            JSON.stringify({\n              source: 'ObjectReferenceResolver',\n              keys: Object.keys(resolved),\n              hasProperties: true\n            }) + '\\n'\n          );\n        } catch {}\n      }\n      return resolved;\n    }\n\n    // Fallback - treat as plain object\n    return this.resolveNestedStructures(value, variableMap);\n  }\n\n  /**\n   * Recursively resolve references in nested objects and arrays\n   */\n  private resolveNestedStructures(value: any, variableMap: Map<string, Variable>, options?: { resolveStrings?: boolean }): any {\n    const resolved: Record<string, any> = {};\n    for (const [key, val] of Object.entries(value)) {\n      resolved[key] = this.resolveObjectReferences(val, variableMap, options);\n    }\n    return resolved;\n  }\n}\n","export type PolicyLimits = {\n  maxTokens?: number;\n  timeout?: number;\n};\n\nexport type PolicyConfig = {\n  allow?: Record<string, string[] | true> | true;\n  deny?: Record<string, string[] | true> | true;\n  limits?: PolicyLimits;\n};\n\ntype AllowShape =\n  | { type: 'wildcard' }\n  | { type: 'map'; entries: Map<string, Set<string>> };\n\ntype DenyShape =\n  | { type: 'wildcard' }\n  | { type: 'map'; entries: Map<string, Set<string>> };\n\nexport function mergePolicyConfigs(\n  base: PolicyConfig | undefined,\n  incoming: PolicyConfig | undefined\n): PolicyConfig {\n  if (!base) {\n    return normalizePolicyConfig(incoming);\n  }\n  if (!incoming) {\n    return normalizePolicyConfig(base);\n  }\n\n  const baseAllow = toAllowShape(base.allow);\n  const incomingAllow = toAllowShape(incoming.allow);\n  const mergedAllow = mergeAllowShapes(baseAllow, incomingAllow);\n\n  const baseDeny = toDenyShape(base.deny);\n  const incomingDeny = toDenyShape(incoming.deny);\n  const mergedDeny = mergeDenyShapes(baseDeny, incomingDeny);\n\n  const limits = mergeLimits(base.limits, incoming.limits);\n\n  return {\n    allow: fromAllowShape(mergedAllow),\n    deny: fromDenyShape(mergedDeny),\n    ...(limits ? { limits } : {})\n  };\n}\n\nexport function normalizePolicyConfig(config?: PolicyConfig): PolicyConfig {\n  if (!config) {\n    return {};\n  }\n  const allow = config.allow !== undefined ? fromAllowShape(toAllowShape(config.allow)) : undefined;\n  const deny = config.deny !== undefined ? fromDenyShape(toDenyShape(config.deny)) : undefined;\n  const limits = config.limits ? normalizeLimits(config.limits) : undefined;\n  return { allow, deny, ...(limits ? { limits } : {}) };\n}\n\nfunction toAllowShape(value: PolicyConfig['allow']): AllowShape {\n  if (value === true || value === '*' || value === 'all') {\n    return { type: 'wildcard' };\n  }\n\n  const entries = new Map<string, Set<string>>();\n  if (Array.isArray(value)) {\n    entries.set('default', new Set(value.map(String)));\n    return { type: 'map', entries };\n  }\n\n  if (value && typeof value === 'object') {\n    for (const [key, raw] of Object.entries(value)) {\n      if (raw === true || raw === '*' || raw === 'all') {\n        entries.set(key, new Set(['*']));\n        continue;\n      }\n      const vals = Array.isArray(raw) ? raw.map(String) : [String(raw)];\n      entries.set(key, new Set(vals));\n    }\n    return { type: 'map', entries };\n  }\n\n  return { type: 'map', entries };\n}\n\nfunction fromAllowShape(shape: AllowShape): PolicyConfig['allow'] {\n  if (shape.type === 'wildcard') {\n    return true;\n  }\n  const result: Record<string, string[]> = {};\n  for (const [key, values] of shape.entries.entries()) {\n    if (values.has('*')) {\n      result[key] = ['*'];\n    } else {\n      result[key] = Array.from(values);\n    }\n  }\n  return result;\n}\n\nfunction mergeAllowShapes(a: AllowShape, b: AllowShape): AllowShape {\n  if (a.type === 'wildcard') return b;\n  if (b.type === 'wildcard') return a;\n\n  const entries = new Map<string, Set<string>>();\n  for (const [key, aSet] of a.entries.entries()) {\n    const bSet = b.entries.get(key);\n    if (!bSet) {\n      continue;\n    }\n    if (aSet.has('*')) {\n      entries.set(key, new Set(bSet));\n    } else if (bSet.has('*')) {\n      entries.set(key, new Set(aSet));\n    } else {\n      const intersection = new Set<string>();\n      for (const val of aSet) {\n        if (bSet.has(val)) {\n          intersection.add(val);\n        }\n      }\n      entries.set(key, intersection);\n    }\n  }\n\n  return { type: 'map', entries };\n}\n\nfunction toDenyShape(value: PolicyConfig['deny']): DenyShape {\n  if (value === true || value === '*' || value === 'all') {\n    return { type: 'wildcard' };\n  }\n\n  const entries = new Map<string, Set<string>>();\n  if (Array.isArray(value)) {\n    entries.set('default', new Set(value.map(String)));\n    return { type: 'map', entries };\n  }\n\n  if (value && typeof value === 'object') {\n    for (const [key, raw] of Object.entries(value)) {\n      if (raw === true || raw === '*' || raw === 'all') {\n        entries.set(key, new Set(['*']));\n        continue;\n      }\n      const vals = Array.isArray(raw) ? raw.map(String) : [String(raw)];\n      entries.set(key, new Set(vals));\n    }\n    return { type: 'map', entries };\n  }\n\n  return { type: 'map', entries };\n}\n\nfunction fromDenyShape(shape: DenyShape): PolicyConfig['deny'] {\n  if (shape.type === 'wildcard') {\n    return true;\n  }\n  const result: Record<string, string[]> = {};\n  for (const [key, values] of shape.entries.entries()) {\n    if (values.has('*')) {\n      result[key] = ['*'];\n    } else {\n      result[key] = Array.from(values);\n    }\n  }\n  return result;\n}\n\nfunction mergeDenyShapes(a: DenyShape, b: DenyShape): DenyShape {\n  if (a.type === 'wildcard' || b.type === 'wildcard') {\n    return { type: 'wildcard' };\n  }\n\n  const entries = new Map<string, Set<string>>();\n  for (const [key, set] of a.entries.entries()) {\n    entries.set(key, new Set(set));\n  }\n\n  for (const [key, set] of b.entries.entries()) {\n    const existing = entries.get(key);\n    if (!existing) {\n      entries.set(key, new Set(set));\n      continue;\n    }\n    if (existing.has('*') || set.has('*')) {\n      entries.set(key, new Set(['*']));\n      continue;\n    }\n    for (const val of set) {\n      existing.add(val);\n    }\n  }\n\n  return { type: 'map', entries };\n}\n\nfunction mergeLimits(a?: PolicyLimits, b?: PolicyLimits): PolicyLimits | undefined {\n  if (!a && !b) {\n    return undefined;\n  }\n  const limits: PolicyLimits = {};\n  if (a?.maxTokens !== undefined || b?.maxTokens !== undefined) {\n    limits.maxTokens = Math.min(\n      a?.maxTokens ?? Number.POSITIVE_INFINITY,\n      b?.maxTokens ?? Number.POSITIVE_INFINITY\n    );\n  }\n  if (a?.timeout !== undefined || b?.timeout !== undefined) {\n    limits.timeout = Math.min(\n      a?.timeout ?? Number.POSITIVE_INFINITY,\n      b?.timeout ?? Number.POSITIVE_INFINITY\n    );\n  }\n  return limits;\n}\n\nfunction normalizeLimits(limits: PolicyLimits): PolicyLimits {\n  const normalized: PolicyLimits = {};\n  if (typeof limits.maxTokens === 'number') {\n    normalized.maxTokens = limits.maxTokens;\n  }\n  if (typeof limits.timeout === 'number') {\n    normalized.timeout = limits.timeout;\n  }\n  return normalized;\n}\n","import type { DirectiveNode, ImportDirectiveNode } from '@core/types';\nimport type { ImportType, DataLabel } from '@core/types/security';\nimport { makeSecurityDescriptor, mergeDescriptors } from '@core/types/security';\nimport { deriveImportTaint } from '@core/security/taint';\nimport type { Environment } from '../../env/Environment';\nimport type { EvalResult } from '../../core/interpreter';\nimport { ImportPathResolver, ImportResolution } from './ImportPathResolver';\nimport { ImportSecurityValidator } from './ImportSecurityValidator';\nimport { ModuleContentProcessor, type ModuleProcessingResult } from './ModuleContentProcessor';\nimport { VariableImporter } from './VariableImporter';\nimport { ObjectReferenceResolver } from './ObjectReferenceResolver';\nimport { MlldImportError, ErrorSeverity } from '@core/errors';\n// createVariableFromValue is now part of VariableImporter\nimport { interpolate } from '../../core/interpreter';\nimport { mergePolicyConfigs, normalizePolicyConfig, type PolicyConfig } from '@core/policy/union';\nimport type { NeedsDeclaration, CommandNeeds } from '@core/policy/needs';\nimport type { IFileSystemService } from '@services/fs/IFileSystemService';\nimport { spawnSync } from 'child_process';\nimport { createRequire } from 'module';\nimport * as path from 'path';\nimport minimatch from 'minimatch';\nimport type { SerializedGuardDefinition } from '../../guards';\n\nconst MODULE_SOURCE_EXTENSIONS = ['.mld.md', '.mld', '.md', '.mlld.md', '.mlld'] as const;\nconst DIRECTORY_INDEX_FILENAME = 'index.mld';\nconst DEFAULT_DIRECTORY_IMPORT_SKIP_DIRS = ['_*', '.*'] as const;\n\nfunction matchesModuleExtension(candidate: string): boolean {\n  return MODULE_SOURCE_EXTENSIONS.some(ext => candidate.endsWith(ext));\n}\n\n/**\n * Main coordinator for import directive evaluation\n * Orchestrates all import processing components\n */\nexport class ImportDirectiveEvaluator {\n  private env: Environment;\n  private pathResolver: ImportPathResolver;\n  private securityValidator: ImportSecurityValidator;\n  private contentProcessor: ModuleContentProcessor;\n  private variableImporter: VariableImporter;\n  private objectResolver: ObjectReferenceResolver;\n  // TODO: Integrate capability context construction when import types and security descriptors land.\n\n  constructor(env: Environment) {\n    this.env = env;\n    this.objectResolver = new ObjectReferenceResolver();\n    this.pathResolver = new ImportPathResolver(env);\n    this.securityValidator = new ImportSecurityValidator(env);\n    this.variableImporter = new VariableImporter(this.objectResolver);\n    this.contentProcessor = new ModuleContentProcessor(\n      env, \n      this.securityValidator, \n      this.variableImporter\n    );\n  }\n\n  /**\n   * Main entry point for import directive evaluation\n   */\n  async evaluateImport(directive: DirectiveNode, env: Environment): Promise<EvalResult> {\n    try {\n      // 1. Resolve the import path and determine import type\n      const resolution = await this.pathResolver.resolveImportPath(directive);\n\n      const importContext = this.resolveImportType(directive, resolution);\n      resolution.importType = importContext.importType;\n      if (importContext.cacheDurationMs !== undefined) {\n        resolution.cacheDurationMs = importContext.cacheDurationMs;\n      }\n\n      if (resolution.importType === 'templates' && resolution.type !== 'file') {\n        const resolvedPath = await env.resolvePath(resolution.resolvedPath);\n        resolution.resolvedPath = resolvedPath;\n        resolution.type = 'file';\n      }\n\n      if (\n        (directive as any)?.values?.templateParams &&\n        (directive as any).values.templateParams.length > 0 &&\n        resolution.importType !== 'templates'\n      ) {\n        throw new MlldImportError('Import parameters are only supported with templates imports', {\n          code: 'IMPORT_TYPE_MISMATCH',\n          details: {\n            importType: resolution.importType,\n            path: resolution.resolvedPath\n          }\n        });\n      }\n\n      const securityLabels = (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined;\n      const baseDescriptor = makeSecurityDescriptor({ labels: securityLabels });\n      const taintSnapshot = deriveImportTaint({\n        importType: resolution.importType ?? 'live',\n        resolverName: resolution.resolverName,\n        source: resolution.resolvedPath,\n        resolvedPath: resolution.resolvedPath,\n        sourceType: resolution.type,\n        labels: resolution.mx?.labels\n      });\n      const taintDescriptor = makeSecurityDescriptor({\n      taint: taintSnapshot.taint,\n      labels: taintSnapshot.labels,\n      sources: taintSnapshot.sources\n    });\n      const descriptor = mergeDescriptors(baseDescriptor, taintDescriptor);\n\n      // 2. Route to appropriate handler based on import type\n      return await this.withPolicyOverride(\n        directive,\n        env,\n        async () => await this.routeImportRequest(resolution, directive, env)\n      );\n\n    } catch (error) {\n      return this.handleImportError(error, directive, env);\n    }\n  }\n\n  /**\n   * Route import request to appropriate handler\n   */\n  private async routeImportRequest(\n    resolution: ImportResolution,\n    directive: DirectiveNode,\n    env: Environment\n  ): Promise<EvalResult> {\n    switch (resolution.type) {\n      case 'input':\n        return this.evaluateInputImport(directive, env);\n      \n      case 'resolver':\n        return this.evaluateResolverImport(directive, resolution.resolverName!, env);\n      \n      case 'module':\n        return this.evaluateModuleImport(resolution, directive, env);\n      \n      case 'file':\n      case 'url':\n        return this.evaluateFileImport(resolution, directive, env);\n      \n      default:\n        throw new Error(`Unknown import type: ${(resolution as any).type}`);\n    }\n  }\n\n  /**\n   * Handle input imports (@input, @stdin)\n   */\n  private resolveImportType(\n    directive: DirectiveNode,\n    resolution: ImportResolution\n  ): { importType: ImportType; cacheDurationMs?: number } {\n    const importDirective = directive as ImportDirectiveNode;\n    const declaredType = importDirective.values?.importType;\n    const cachedDuration = importDirective.values?.cachedDuration;\n\n    if (declaredType) {\n      this.validateDeclaredImportType(declaredType, resolution);\n    }\n\n    if (declaredType === 'local' && resolution.type === 'module') {\n      resolution.preferLocal = true;\n    }\n\n    const resolvedType = declaredType ?? this.inferImportType(resolution);\n    const cacheDurationMs = resolvedType === 'cached'\n      ? this.durationToMilliseconds(cachedDuration)\n      : undefined;\n\n    return {\n      importType: resolvedType,\n      cacheDurationMs\n    };\n  }\n\n  private inferImportType(resolution: ImportResolution): ImportType {\n    switch (resolution.type) {\n      case 'module':\n        return 'module';\n      case 'file':\n        return 'static';\n      case 'url':\n        return 'cached';\n      case 'input':\n        return 'live';\n      case 'resolver':\n        return this.inferResolverImportType(resolution);\n      default:\n        return 'live';\n    }\n  }\n\n  private inferResolverImportType(resolution: ImportResolution): ImportType {\n    const name = resolution.resolverName?.toLowerCase();\n    if (!name) {\n      return 'live';\n    }\n\n    if (name === 'local') {\n      return 'local';\n    }\n\n    if (name === 'base' || name === 'root' || name === 'project') {\n      return 'static';\n    }\n\n    return 'live';\n  }\n\n  private validateDeclaredImportType(type: ImportType, resolution: ImportResolution): void {\n    const resolverName = resolution.resolverName?.toLowerCase();\n\n    switch (type) {\n      case 'module':\n        if (resolution.type !== 'module') {\n          throw new MlldImportError(\"Import type 'module' requires a registry module reference.\", {\n            code: 'IMPORT_TYPE_MISMATCH',\n            details: { importType: type, resolvedType: resolution.type }\n          });\n        }\n        return;\n\n      case 'cached':\n        if (resolution.type !== 'url') {\n          throw new MlldImportError(\"Import type 'cached' requires an absolute URL source.\", {\n            code: 'IMPORT_TYPE_MISMATCH',\n            details: { importType: type, resolvedType: resolution.type }\n          });\n        }\n        return;\n\n      case 'local':\n        if (resolution.type === 'module') {\n          resolution.preferLocal = true;\n          return;\n        }\n        if (resolution.type !== 'resolver' || resolverName !== 'local') {\n          throw new MlldImportError(\"Import type 'local' expects an @local/... module.\", {\n            code: 'IMPORT_TYPE_MISMATCH',\n            details: { importType: type, resolvedType: resolution.type }\n          });\n        }\n        return;\n\n      case 'static':\n        if (resolution.type === 'file') {\n          return;\n        }\n        if (resolution.type === 'resolver' && (resolverName === 'base' || resolverName === 'root' || resolverName === 'project')) {\n          return;\n        }\n        throw new MlldImportError(\"Import type 'static' supports local files or @base/@root/@project resolver paths.\", {\n          code: 'IMPORT_TYPE_MISMATCH',\n          details: { importType: type, resolvedType: resolution.type }\n        });\n\n      case 'live':\n        if (resolution.type === 'url' || resolution.type === 'resolver' || resolution.type === 'input') {\n          return;\n        }\n        throw new MlldImportError(\"Import type 'live' is only valid for resolvers, URLs, or @input.\", {\n          code: 'IMPORT_TYPE_MISMATCH',\n          details: { importType: type, resolvedType: resolution.type }\n        });\n\n      case 'templates': {\n        const isAllowedResolver =\n          resolution.type === 'resolver' &&\n          (resolverName === 'base' || resolverName === 'root' || resolverName === 'project' || resolverName === 'local');\n        if (resolution.type === 'file' || isAllowedResolver) {\n          return;\n        }\n        throw new MlldImportError(\"Import type 'templates' expects a directory from the local filesystem or @base/@root/@project/@local resolvers.\", {\n          code: 'IMPORT_TYPE_MISMATCH',\n          details: { importType: type, resolvedType: resolution.type }\n        });\n      }\n\n      default:\n        return;\n    }\n  }\n\n  private durationToMilliseconds(duration?: ImportDirectiveNode['values']['cachedDuration']): number | undefined {\n    if (!duration) {\n      return undefined;\n    }\n\n    const multipliers: Record<string, number> = {\n      seconds: 1000,\n      minutes: 60 * 1000,\n      hours: 60 * 60 * 1000,\n      days: 24 * 60 * 60 * 1000,\n      weeks: 7 * 24 * 60 * 60 * 1000,\n      years: 365 * 24 * 60 * 60 * 1000\n    };\n\n    const value = multipliers[duration.unit];\n    if (!value) {\n      return undefined;\n    }\n\n    return duration.value * value;\n  }\n\n  /**\n   * Handle input imports (@input, @stdin)\n   */\n  private async evaluateInputImport(directive: DirectiveNode, env: Environment): Promise<EvalResult> {\n    // Get input resolver\n    const resolverManager = env.getResolverManager();\n    if (!resolverManager) {\n      throw new Error('Resolver manager not available');\n    }\n\n    const resolver = resolverManager.getResolver('input');\n    if (!resolver) {\n      throw new Error('input resolver not found');\n    }\n\n    // Extract requested imports for the resolver\n    const requestedImports = directive.subtype === 'importSelected' \n      ? (directive.values?.imports || []).map((imp: any) => imp.identifier)\n      : undefined;\n\n    // Use resolver to get input data with proper import context\n    const result = await resolver.resolve('@input', { \n      context: 'import',\n      requestedImports\n    });\n    \n    let exportData: Record<string, any> = {};\n    if (result.contentType === 'data' && typeof result.content === 'string') {\n      try {\n        exportData = JSON.parse(result.content);\n      } catch (e) {\n        exportData = { value: result.content };\n      }\n    } else {\n      exportData = { value: result.content };\n    }\n\n    // Import variables based on directive type\n    await this.importResolverVariables(directive, exportData, env, '@input');\n\n    return { value: undefined, env };\n  }\n\n  /**\n   * Handle resolver imports (@now, @debug, etc.)\n   */\n  private async evaluateResolverImport(\n    directive: DirectiveNode,\n    resolverName: string,\n    env: Environment\n  ): Promise<EvalResult> {\n    const resolverManager = env.getResolverManager();\n    if (!resolverManager) {\n      throw new Error('Resolver manager not available');\n    }\n\n    // Try case-sensitive first, then uppercase for backward compatibility\n    const resolver = resolverManager.getResolver(resolverName) || \n                    resolverManager.getResolver(resolverName.toUpperCase());\n    if (!resolver) {\n      throw new Error(`Resolver '${resolverName}' not found`);\n    }\n\n    // Check if resolver supports imports\n    if (!resolver.capabilities.contexts.import) {\n      const { ResolverError } = await import('@core/errors');\n      throw ResolverError.unsupportedCapability(resolver.name, 'imports', 'import');\n    }\n\n    const requestedImports = directive.subtype === 'importSelected'\n      ? (directive.values?.imports || []).map((imp: any) => imp.identifier)\n      : undefined;\n\n    const resolverResult = await resolver.resolve(`@${resolverName}`, {\n      context: 'import',\n      requestedImports\n    });\n\n    if (resolverResult.contentType === 'module') {\n      const ref = resolverResult.mx?.source ?? `@${resolverName}`;\n      const taintDescriptor = deriveImportTaint({\n        importType: 'module',\n        resolverName,\n        source: ref,\n        resolvedPath: ref,\n        sourceType: 'resolver',\n        labels: resolverResult.mx?.labels\n      });\n      env.recordSecurityDescriptor(\n        makeSecurityDescriptor({\n          taint: taintDescriptor.taint,\n          labels: taintDescriptor.labels,\n          sources: taintDescriptor.sources\n        })\n      );\n      return this.importFromResolverContent(directive, ref, resolverResult, env);\n    }\n\n    // Get export data from resolver\n    let exportData: Record<string, any> = {};\n    \n    if ('getExportData' in resolver) {\n      exportData = await this.getResolverExportData(resolver as any, directive, resolverName);\n    } else {\n      exportData = await this.fallbackResolverData(resolver, directive, resolverName, resolverResult);\n    }\n\n    // Import variables based on directive type\n    await this.importResolverVariables(directive, exportData, env, `@${resolverName}`);\n\n    return { value: undefined, env };\n  }\n\n  /**\n   * Handle module imports (@user/module)\n   */\n  private async evaluateModuleImport(\n    resolution: ImportResolution,\n    directive: DirectiveNode,\n    env: Environment\n  ): Promise<EvalResult> {\n    if (resolution.preferLocal) {\n      const resolverManager = env.getResolverManager();\n      if (!resolverManager || !resolverManager.hasLocalModule(resolution.resolvedPath)) {\n        throw new MlldImportError(`Local module not found for ${resolution.resolvedPath}`, {\n          code: 'LOCAL_MODULE_NOT_FOUND',\n          severity: ErrorSeverity.Fatal,\n          details: { reference: resolution.resolvedPath }\n        });\n      }\n    }\n\n    const candidates = this.buildModuleCandidates(resolution);\n    let lastError: unknown = undefined;\n\n    for (const candidate of candidates) {\n      try {\n        const resolverContent = await env.resolveModule(candidate, 'import');\n        if (resolverContent.resolverName) {\n          resolution.resolverName = resolverContent.resolverName;\n        }\n\n        const treatAsModule = resolverContent.contentType === 'module'\n          || matchesModuleExtension(candidate);\n\n        if (!treatAsModule) {\n          lastError = new Error(\n            `Import target is not a module: ${candidate} (content type: ${resolverContent.contentType})`\n          );\n          continue;\n        }\n\n        const importDescriptor = deriveImportTaint({\n          importType: resolution.importType ?? 'module',\n          resolverName: resolverContent.resolverName,\n          source: resolverContent.mx?.source ?? resolution.resolvedPath,\n          resolvedPath: resolverContent.mx?.source ?? resolution.resolvedPath,\n          sourceType: 'module',\n          labels: resolverContent.mx?.labels\n        });\n        env.recordSecurityDescriptor(\n          makeSecurityDescriptor({\n            taint: importDescriptor.taint,\n            labels: importDescriptor.labels,\n            sources: importDescriptor.sources\n          })\n        );\n\n        // Validate version against lock file for registry modules\n        await this.validateLockFileVersion(candidate, resolverContent, env);\n\n        return this.importFromResolverContent(directive, candidate, resolverContent, env);\n      } catch (error) {\n        if ((error as any)?.code === 'IMPORT_NO_EXPORTS') {\n          lastError = error;\n          break;\n        }\n        lastError = error;\n      }\n    }\n\n    if (lastError) {\n      throw lastError;\n    }\n\n    throw new Error(`Unable to resolve module import: ${resolution.resolvedPath}`);\n  }\n\n  /**\n   * Handle file and URL imports\n   */\n  private async evaluateFileImport(\n    resolution: ImportResolution,\n    directive: DirectiveNode,\n    env: Environment\n  ): Promise<EvalResult> {\n    const directoryResult = await this.maybeProcessDirectoryImport(resolution, directive, env);\n\n    // Process the file/URL content (handles its own import tracking)\n    const processingResult =\n      directoryResult ?? (await this.contentProcessor.processModuleContent(resolution, directive));\n\n    this.validateModuleResult(processingResult, directive, resolution.resolvedPath);\n\n    // Import variables into environment\n    await this.variableImporter.importVariables(processingResult, directive, env);\n    this.applyPolicyImportContext(directive, env, resolution.resolvedPath);\n\n    return { value: undefined, env };\n  }\n\n  private async maybeProcessDirectoryImport(\n    resolution: ImportResolution,\n    directive: DirectiveNode,\n    env: Environment\n  ): Promise<ModuleProcessingResult | null> {\n    if (resolution.type !== 'file') {\n      return null;\n    }\n\n    if (resolution.importType === 'templates') {\n      return null;\n    }\n\n    const fsService = env.getFileSystemService();\n    if (typeof fsService.isDirectory !== 'function') {\n      return null;\n    }\n\n    const baseDir = resolution.resolvedPath;\n    const isDir = await fsService.isDirectory(baseDir);\n    if (!isDir) {\n      return null;\n    }\n\n    return await this.processDirectoryImport(fsService, baseDir, resolution, directive, env);\n  }\n\n  private async processDirectoryImport(\n    fsService: IFileSystemService,\n    baseDir: string,\n    resolution: ImportResolution,\n    directive: DirectiveNode,\n    env: Environment\n  ): Promise<ModuleProcessingResult> {\n    if (typeof fsService.readdir !== 'function' || typeof fsService.stat !== 'function') {\n      throw new MlldImportError('Directory import requires filesystem access', {\n        code: 'DIRECTORY_IMPORT_FS_UNAVAILABLE',\n        details: { path: baseDir }\n      });\n    }\n\n    const skipDirs = this.getDirectoryImportSkipDirs(directive, baseDir);\n    const moduleObject: Record<string, any> = {};\n    const guardDefinitions: SerializedGuardDefinition[] = [];\n\n    const entries = await fsService.readdir(baseDir);\n    for (const entry of entries) {\n      const fullPath = path.join(baseDir, entry);\n      const stat = await fsService\n        .stat(fullPath)\n        .catch(() => ({ isDirectory: () => false, isFile: () => false }));\n      if (!stat.isDirectory()) {\n        continue;\n      }\n\n      if (this.shouldSkipDirectory(entry, skipDirs)) {\n        continue;\n      }\n\n      const indexPath = path.join(fullPath, DIRECTORY_INDEX_FILENAME);\n      const hasIndex = await fsService.exists(indexPath).catch(() => false);\n      if (!hasIndex) {\n        continue;\n      }\n\n      const indexStat = await fsService\n        .stat(indexPath)\n        .catch(() => ({ isDirectory: () => false, isFile: () => false }));\n      if (!indexStat.isFile()) {\n        continue;\n      }\n\n      const childResolution: ImportResolution = {\n        type: 'file',\n        resolvedPath: indexPath,\n        importType: resolution.importType\n      };\n\n      const childResult = await this.contentProcessor.processModuleContent(childResolution, directive);\n      this.enforceModuleNeeds(childResult.moduleNeeds, indexPath);\n\n      const key = this.sanitizeDirectoryKey(entry);\n      if (key in moduleObject) {\n        throw new MlldImportError(`Duplicate directory import key '${key}' under ${baseDir}`, {\n          code: 'DIRECTORY_IMPORT_DUPLICATE_KEY',\n          details: { path: baseDir, key, entries: [entry] }\n        });\n      }\n\n      moduleObject[key] = childResult.moduleObject;\n      if (childResult.guardDefinitions && childResult.guardDefinitions.length > 0) {\n        guardDefinitions.push(...childResult.guardDefinitions);\n      }\n    }\n\n    if (Object.keys(moduleObject).length === 0) {\n      throw new MlldImportError(`No ${DIRECTORY_INDEX_FILENAME} modules found under ${baseDir}`, {\n        code: 'DIRECTORY_IMPORT_EMPTY',\n        details: { path: baseDir, index: DIRECTORY_INDEX_FILENAME }\n      });\n    }\n\n    const childEnv = env.createChild(baseDir);\n    childEnv.setCurrentFilePath(baseDir);\n\n    return {\n      moduleObject,\n      frontmatter: null,\n      childEnvironment: childEnv,\n      guardDefinitions\n    };\n  }\n\n  private getDirectoryImportSkipDirs(directive: DirectiveNode, baseDir: string): string[] {\n    const withClause = (directive.meta?.withClause || directive.values?.withClause) as any | undefined;\n    if (!withClause || !('skipDirs' in withClause)) {\n      return [...DEFAULT_DIRECTORY_IMPORT_SKIP_DIRS];\n    }\n\n    const value = (withClause as any).skipDirs as unknown;\n    const parsed = this.parseStringArrayOption(value, { option: 'skipDirs', source: baseDir });\n    return parsed;\n  }\n\n  private parseStringArrayOption(\n    value: unknown,\n    context: { option: string; source: string }\n  ): string[] {\n    if (Array.isArray(value)) {\n      const coerced = value.map(item => this.coerceStringLiteral(item)).filter((v): v is string => v !== null);\n      if (coerced.length !== value.length) {\n        throw new MlldImportError(`Import with { ${context.option}: [...] } only supports string values`, {\n          code: 'DIRECTORY_IMPORT_INVALID_OPTION',\n          details: { option: context.option, source: context.source }\n        });\n      }\n      return coerced;\n    }\n\n    if (this.isArrayLiteralAst(value)) {\n      const coerced = value.items.map(item => this.coerceStringLiteral(item)).filter((v): v is string => v !== null);\n      if (coerced.length !== value.items.length) {\n        throw new MlldImportError(`Import with { ${context.option}: [...] } only supports string values`, {\n          code: 'DIRECTORY_IMPORT_INVALID_OPTION',\n          details: { option: context.option, source: context.source }\n        });\n      }\n      return coerced;\n    }\n\n    throw new MlldImportError(`Import with { ${context.option}: [...] } expects an array`, {\n      code: 'DIRECTORY_IMPORT_INVALID_OPTION',\n      details: { option: context.option, source: context.source }\n    });\n  }\n\n  private isArrayLiteralAst(value: unknown): value is { type: 'array'; items: unknown[] } {\n    return Boolean(\n      value &&\n        typeof value === 'object' &&\n        'type' in value &&\n        (value as any).type === 'array' &&\n        'items' in value &&\n        Array.isArray((value as any).items)\n    );\n  }\n\n  private coerceStringLiteral(value: unknown): string | null {\n    if (typeof value === 'string') {\n      return value;\n    }\n\n    if (value && typeof value === 'object') {\n      if ((value as any).type === 'Literal' && (value as any).valueType === 'string') {\n        return String((value as any).value ?? '');\n      }\n\n      if ('content' in value && Array.isArray((value as any).content)) {\n        const parts = (value as any).content as any[];\n        const hasOnlyLiteralOrText = parts.every(\n          node =>\n            node &&\n            typeof node === 'object' &&\n            ((node.type === 'Literal' && 'value' in node) || (node.type === 'Text' && 'content' in node))\n        );\n        if (!hasOnlyLiteralOrText) {\n          return null;\n        }\n        return parts.map(node => (node.type === 'Literal' ? String(node.value ?? '') : String(node.content ?? ''))).join('');\n      }\n    }\n\n    return null;\n  }\n\n  private shouldSkipDirectory(dirName: string, patterns: string[]): boolean {\n    return patterns.some(pattern => minimatch(dirName, pattern, { dot: true }));\n  }\n\n  private sanitizeDirectoryKey(name: string): string {\n    // Preserve hyphens in directory names - they're valid in mlld identifiers\n    const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_');\n    return sanitized.length > 0 ? sanitized : 'module';\n  }\n\n  /**\n   * Import from resolver content (already resolved)\n   */\n  private async importFromResolverContent(\n    directive: DirectiveNode,\n    ref: string,\n    resolverContent: { content: string; contentType: 'module' | 'data' | 'text'; metadata?: any },\n    env: Environment\n  ): Promise<EvalResult> {\n    // Check for circular imports\n    if (this.securityValidator.checkCircularImports(ref)) {\n      throw new Error(`Circular import detected: ${ref}`);\n    }\n\n    try {\n      if (process.env.MLLD_DEBUG === 'true') {\n        console.log(`[ImportDirectiveEvaluator] Resolver content for ${ref}:`, {\n          contentLength: resolverContent.content.length,\n          contentType: resolverContent.contentType,\n          firstChars: resolverContent.content.substring(0, 100)\n        });\n      }\n      \n      // Process the content through our content processor\n      \n      const processingRef = typeof resolverContent.metadata?.source === 'string'\n        ? resolverContent.metadata.source\n        : ref;\n\n      const processingResult = await this.contentProcessor.processResolverContent(\n        resolverContent.content,\n        processingRef,\n        directive,\n        resolverContent.contentType,\n        resolverContent.mx?.labels\n      );\n\n      this.validateModuleResult(processingResult, directive, processingRef);\n\n\n      if (process.env.MLLD_DEBUG === 'true') {\n        console.log(`[ImportDirectiveEvaluator] Processing result for ${ref}:`, {\n          moduleObjectKeys: Object.keys(processingResult.moduleObject),\n          moduleObjectSize: Object.keys(processingResult.moduleObject).length,\n          hasFrontmatter: processingResult.frontmatter !== null\n        });\n      }\n\n      // Import variables into environment\n      await this.variableImporter.importVariables(processingResult, directive, env);\n      this.applyPolicyImportContext(directive, env, processingRef);\n\n      const dynamicSource = resolverContent.mx?.source;\n      if (dynamicSource && typeof dynamicSource === 'string' && dynamicSource.startsWith('dynamic://')) {\n        const childVariables = processingResult.childEnvironment.getAllVariables?.();\n        const parentVariables = env.getAllVariables?.();\n        const exportedNames =\n          env.getExportManifest()?.getNames?.() ??\n          (Array.isArray(resolverContent.metadata?.exports)\n            ? (resolverContent.metadata.exports as string[])\n            : undefined) ??\n          processingResult.childEnvironment.getExportManifest?.()?.getNames?.() ??\n          (childVariables ? Array.from(childVariables.keys()) : undefined) ??\n          (parentVariables ? Array.from(parentVariables.keys()) : undefined) ??\n          Object.keys(processingResult.moduleObject ?? {});\n        const provenance =\n          env.isProvenanceEnabled?.() === true\n            ? resolverContent.metadata?.provenance ??\n              this.buildDynamicImportProvenance(dynamicSource ?? ref, env)\n            : undefined;\n        env.emitSDKEvent({\n          type: 'debug:import:dynamic',\n          path: ref,\n          source: dynamicSource,\n          tainted: true,\n          variables: exportedNames,\n          timestamp: Date.now(),\n          ...(provenance && { provenance })\n        });\n      }\n\n      return { value: undefined, env };\n    } finally {\n      // Import tracking handled by ModuleContentProcessor.processResolverContent\n    }\n  }\n\n\n  /**\n   * Get export data from resolver with format support\n   */\n  private async getResolverExportData(\n    resolver: any,\n    directive: DirectiveNode,\n    resolverName: string\n  ): Promise<Record<string, any>> {\n    // Handle selected imports with format support\n    if (directive.subtype === 'importSelected') {\n      const imports = directive.values?.imports || [];\n      \n      // For single format import like: @import { \"iso\" as date } from @TIME\n      if (imports.length === 1) {\n        const importNode = imports[0];\n        const format = importNode.identifier.replace(/^[\"']|[\"']$/g, ''); // Remove quotes\n        \n        // Check if this is a format string (quoted)\n        if (importNode.identifier.startsWith('\"') || importNode.identifier.startsWith('\\'')) {\n          const exportData = await resolver.getExportData(format);\n          \n          // Return single item for direct import\n          return { [importNode.alias || format]: exportData[format] };\n        }\n      }\n      \n      // Otherwise get all export data for field selection\n      return await resolver.getExportData();\n    } else {\n      // Import all - get all export data\n      return await resolver.getExportData();\n    }\n  }\n\n  /**\n   * Fallback resolver data handling\n   */\n  private async fallbackResolverData(\n    resolver: any,\n    directive: DirectiveNode,\n    resolverName: string,\n    resolvedResult?: { contentType: string; content: any }\n  ): Promise<Record<string, any>> {\n    const requestedImports = directive.subtype === 'importSelected' \n      ? (directive.values?.imports || []).map((imp: any) => imp.identifier)\n      : undefined;\n    \n    const result =\n      resolvedResult ??\n      (await resolver.resolve(`@${resolverName}`, {\n        context: 'import',\n        requestedImports\n      }));\n    \n    // If content is JSON string (data type), parse it\n    if (result.contentType === 'data' && typeof result.content === 'string') {\n      try {\n        return JSON.parse(result.content);\n      } catch (e) {\n        return { value: result.content };\n      }\n    } else {\n      return { value: result.content };\n    }\n  }\n\n  /**\n   * Import variables from resolver data\n   */\n  private async importResolverVariables(\n    directive: DirectiveNode,\n    exportData: Record<string, any>,\n    env: Environment,\n    sourcePath: string\n  ): Promise<void> {\n    const securityLabels = (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined;\n    if (directive.subtype === 'importSelected') {\n      const imports = directive.values?.imports || [];\n      for (const importItem of imports) {\n        let varName = importItem.identifier.replace(/^[\"']|[\"']$/g, ''); // Remove quotes\n        const alias = importItem.alias || varName;\n        \n        if (varName in exportData) {\n          const value = exportData[varName];\n        const variable = this.variableImporter.createVariableFromValue(alias, value, sourcePath, varName, {\n          securityLabels,\n          env\n        });\n          env.setVariable(alias, variable);\n        } else {\n          throw new Error(`Export '${varName}' not found in resolver '${sourcePath}'`);\n        }\n      }\n    } else {\n      // Import all exports\n      for (const [name, value] of Object.entries(exportData)) {\n        const variable = this.variableImporter.createVariableFromValue(name, value, sourcePath, undefined, {\n          securityLabels,\n          env\n        });\n        env.setVariable(name, variable);\n      }\n    }\n  }\n\n  private buildModuleCandidates(resolution: ImportResolution): string[] {\n    const baseRef = resolution.resolvedPath;\n    const extension = resolution.moduleExtension;\n    const candidates: string[] = [];\n\n    if (extension) {\n      candidates.push(`${baseRef}${extension}`);\n      candidates.push(baseRef);\n      return candidates;\n    }\n\n    const seen = new Set<string>();\n\n    for (const ext of MODULE_SOURCE_EXTENSIONS) {\n      const candidate = `${baseRef}${ext}`;\n      if (!seen.has(candidate)) {\n        seen.add(candidate);\n        candidates.push(candidate);\n      }\n    }\n\n    if (!seen.has(baseRef)) {\n      candidates.push(baseRef);\n    }\n\n    return candidates;\n  }\n  /**\n   * Extract section content from markdown (copied from original)\n   */\n  private extractSection(content: string, sectionName: string): string {\n    const lines = content.split('\\n');\n    const sectionRegex = new RegExp(`^#+\\\\s+${sectionName}\\\\s*$`, 'i');\n    \n    let inSection = false;\n    let sectionLevel = 0;\n    const sectionLines: string[] = [];\n    \n    for (const line of lines) {\n      if (!inSection && sectionRegex.test(line)) {\n        inSection = true;\n        sectionLevel = line.match(/^#+/)?.[0].length || 0;\n        continue;\n      }\n      \n      if (inSection) {\n        const headerMatch = line.match(/^(#+)\\\\s+/);\n        if (headerMatch && headerMatch[1].length <= sectionLevel) {\n          break;\n        }\n        \n        sectionLines.push(line);\n      }\n    }\n    \n    return sectionLines.join('\\n').trim();\n  }\n\n  /**\n   * Validate resolved version against lock file version\n   */\n  private async validateLockFileVersion(\n    candidate: string,\n    resolverContent: { content: string; contentType: 'module' | 'data' | 'text'; metadata?: any },\n    env: Environment\n  ): Promise<void> {\n    // Only validate registry modules (those with version metadata)\n    if (!resolverContent.metadata?.version || !resolverContent.metadata?.source?.startsWith('registry://')) {\n      return;\n    }\n\n    // Extract the module reference from the source\n    const registrySource = resolverContent.metadata.source as string;\n    const moduleMatch = registrySource.match(/^registry:\\/\\/(@[^@]+)@(.+)$/);\n    if (!moduleMatch) {\n      return; // Not a registry module format\n    }\n\n    const [, moduleRef, resolvedVersion] = moduleMatch;\n\n    // Get registry manager to access lock file\n    const registryManager = env.getRegistryManager();\n    if (!registryManager) {\n      return; // No registry manager available\n    }\n\n    const lockFile = registryManager.getLockFile();\n    const lockEntry = lockFile.getImport(moduleRef);\n\n    if (!lockEntry) {\n      // No lock entry found - this is acceptable for new modules\n      // Future enhancement: could warn about unlocked modules\n      return;\n    }\n\n    // Compare versions if lock entry has registryVersion\n    if (lockEntry.registryVersion) {\n      if (lockEntry.registryVersion !== resolvedVersion) {\n        throw new Error(\n          `Locked version mismatch for ${moduleRef}: ` +\n          `lock file has version ${lockEntry.registryVersion}, ` +\n          `but resolved to version ${resolvedVersion}. ` +\n          `Run 'mlld install' to update the lock file or specify the locked version explicitly.`\n        );\n      }\n    } else {\n      // Legacy lock entry without version - handle gracefully\n      if (process.env.MLLD_DEBUG === 'true') {\n        console.warn(`[LockFileValidation] No version field in lock entry for ${moduleRef}. Resolved to ${resolvedVersion}.`);\n      }\n      // Don't fail for legacy entries, but could update the lock entry with the resolved version\n      // This provides a migration path for existing lock files\n    }\n  }\n\n  private buildDynamicImportProvenance(source: string | undefined, env: Environment) {\n    const snapshot = env.getSecuritySnapshot?.();\n    const normalizedSource = source\n      ? source.startsWith('dynamic://')\n        ? source\n        : `dynamic://${source}`\n      : 'dynamic://';\n    return makeSecurityDescriptor({\n      labels: ['untrusted' as DataLabel],\n      taint: snapshot?.taint ?? ['src:dynamic'],\n      sources: snapshot?.sources && snapshot.sources.length > 0 ? snapshot.sources : [normalizedSource],\n      policyContext: snapshot?.policy\n    });\n  }\n\n  /**\n   * Handle import errors with detailed context\n   */\n  private handleImportError(error: any, directive: DirectiveNode, env: Environment): EvalResult {\n    // Enhanced error context could be added here\n    throw error;\n  }\n\n  private async withPolicyOverride<T>(\n    directive: DirectiveNode,\n    env: Environment,\n    operation: () => Promise<T>\n  ): Promise<T> {\n    const overrideConfig = (directive.values as any)?.withClause?.policy as PolicyConfig | undefined;\n    if (!overrideConfig) {\n      return await operation();\n    }\n\n    const previousContext = env.getPolicyContext();\n    const mergedConfig = mergePolicyConfigs(\n      previousContext?.configs as PolicyConfig | undefined,\n      normalizePolicyConfig(overrideConfig)\n    );\n    const nextContext = {\n      tier: previousContext?.tier ?? null,\n      configs: mergedConfig ?? {},\n      activePolicies: previousContext?.activePolicies ?? []\n    };\n\n    env.setPolicyContext(nextContext);\n    try {\n      return await operation();\n    } finally {\n      env.setPolicyContext(previousContext ?? null);\n    }\n  }\n\n  private applyPolicyImportContext(\n    directive: DirectiveNode,\n    env: Environment,\n    source?: string\n  ): void {\n    const isPolicyImport =\n      directive.subtype === 'importPolicy' ||\n      (directive.meta as any)?.importType === 'policy' ||\n      (directive.values as any)?.importType === 'policy';\n    if (!isPolicyImport) {\n      return;\n    }\n\n    const existing = (env.getPolicyContext() as any) || {};\n    const activePolicies = Array.isArray(existing.activePolicies)\n      ? [...existing.activePolicies]\n      : [];\n    const alias =\n      (directive.values as any)?.namespace?.[0]?.content ||\n      (directive.values as any)?.imports?.[0]?.alias ||\n      (directive.values as any)?.imports?.[0]?.identifier ||\n      source ||\n      'policy';\n    if (!activePolicies.includes(alias)) {\n      activePolicies.push(alias);\n    }\n\n    const nextContext = {\n      tier: existing.tier ?? null,\n      configs: existing.configs ?? {},\n      activePolicies\n    };\n    env.setPolicyContext(nextContext);\n  }\n\n  private validateModuleResult(\n    result: ModuleProcessingResult,\n    directive: DirectiveNode,\n    source?: string\n  ): void {\n    this.enforceModuleNeeds(result.moduleNeeds, source);\n    this.validateExportBindings(result.moduleObject, directive, source);\n  }\n\n  private enforceModuleNeeds(needs: NeedsDeclaration | undefined, source?: string): void {\n    if (!needs) {\n      return;\n    }\n\n    const unmet = this.findUnmetNeeds(needs);\n    if (unmet.length === 0) {\n      return;\n    }\n\n    const detailLines = unmet.map(entry => {\n      const valueSegment = entry.value ? ` '${entry.value}'` : '';\n      return `- ${entry.capability}${valueSegment}: ${entry.reason}`;\n    });\n    const label = source ?? 'import';\n    const message = `Import needs not satisfied for ${label}:\\n${detailLines.join('\\n')}`;\n\n    throw new MlldImportError(message, {\n      code: 'NEEDS_UNMET',\n      details: {\n        source: label,\n        unmet,\n        needs\n      }\n    });\n  }\n\n  private findUnmetNeeds(needs: NeedsDeclaration): Array<{ capability: string; value?: string; reason: string }> {\n    const unmet: Array<{ capability: string; value?: string; reason: string }> = [];\n\n    if (needs.sh && !this.isCommandAvailable('sh')) {\n      unmet.push({ capability: 'sh', reason: 'shell executable not available (sh)' });\n    }\n\n    if (needs.cmd) {\n      for (const cmd of this.collectCommandNames(needs.cmd)) {\n        if (!this.isCommandAvailable(cmd)) {\n          unmet.push({ capability: 'cmd', value: cmd, reason: 'command not found in PATH' });\n        }\n      }\n    }\n\n    if (needs.packages) {\n      const basePath = this.env.getBasePath ? this.env.getBasePath() : process.cwd();\n      const moduleDir = this.env.getCurrentFilePath ? path.dirname(this.env.getCurrentFilePath() ?? basePath) : basePath;\n      for (const [ecosystem, packages] of Object.entries(needs.packages)) {\n        if (!Array.isArray(packages)) {\n          continue;\n        }\n        switch (ecosystem) {\n          case 'node':\n            for (const pkg of packages) {\n              if (!this.isNodePackageAvailable(pkg.name, moduleDir)) {\n                unmet.push({ capability: 'node', value: pkg.name, reason: 'package not installed' });\n              }\n            }\n            break;\n          case 'python':\n          case 'py':\n            if (!this.isRuntimeAvailable(['python', 'python3'])) {\n              unmet.push({ capability: 'python', reason: 'python runtime not available' });\n            }\n            break;\n          case 'ruby':\n          case 'rb':\n            if (!this.isRuntimeAvailable(['ruby'])) {\n              unmet.push({ capability: 'ruby', reason: 'ruby runtime not available' });\n            }\n            break;\n          case 'go':\n            if (!this.isRuntimeAvailable(['go'])) {\n              unmet.push({ capability: 'go', reason: 'go runtime not available' });\n            }\n            break;\n          case 'rust':\n            if (!this.isRuntimeAvailable(['cargo', 'rustc'])) {\n              unmet.push({ capability: 'rust', reason: 'rust toolchain not available' });\n            }\n            break;\n          default:\n            break;\n        }\n      }\n    }\n\n    return unmet;\n  }\n\n  private collectCommandNames(cmdNeeds: CommandNeeds): string[] {\n    if (cmdNeeds.type === 'all') {\n      return [];\n    }\n    if (cmdNeeds.type === 'list') {\n      return cmdNeeds.commands;\n    }\n    return Object.keys(cmdNeeds.entries ?? {});\n  }\n\n  private isCommandAvailable(command: string): boolean {\n    if (!command || typeof command !== 'string') {\n      return false;\n    }\n\n    const binary = process.platform === 'win32' ? 'where' : 'which';\n    const result = spawnSync(binary, [command], {\n      stdio: 'ignore'\n    });\n    return result.status === 0;\n  }\n\n  private isRuntimeAvailable(candidates: string[]): boolean {\n    return candidates.some(cmd => this.isCommandAvailable(cmd));\n  }\n\n  private isNodePackageAvailable(name: string, basePath: string): boolean {\n    try {\n      // Use createRequire for ESM compatibility\n      const esmRequire = createRequire(import.meta.url);\n      esmRequire.resolve(name, { paths: [basePath] });\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  private validateExportBindings(moduleObject: Record<string, any>, directive: DirectiveNode, source?: string): void {\n    if (!directive.values) {\n      return;\n    }\n\n    const exportKeys = Object.keys(moduleObject || {}).filter(key => !key.startsWith('__'));\n\n    if (directive.subtype !== 'importSelected') {\n      return;\n    }\n\n    const imports = directive.values?.imports ?? [];\n    for (const importItem of imports) {\n      const name = (importItem as any)?.identifier;\n      if (typeof name !== 'string') {\n        continue;\n      }\n      if (!exportKeys.includes(name)) {\n        throw new MlldImportError(`Import '${name}' not found in module '${source ?? 'import'}'`, {\n          code: 'IMPORT_EXPORT_MISSING',\n          details: { source, missing: name }\n        });\n      }\n    }\n  }\n}\n","/**\n * Refactored import system - modular architecture\n * \n * This module exports the new import directive evaluator that coordinates\n * all import processing through focused, maintainable components.\n */\n\nexport { ImportDirectiveEvaluator } from './ImportDirectiveEvaluator';\nexport { ImportPathResolver, type ImportResolution } from './ImportPathResolver';\nexport { ImportSecurityValidator, type SecurityValidation } from './ImportSecurityValidator';\nexport { ModuleContentProcessor, type ModuleProcessingResult } from './ModuleContentProcessor';\nexport { VariableImporter } from './VariableImporter';\nexport { ObjectReferenceResolver } from './ObjectReferenceResolver';\n\n// Re-export the main evaluation function for backward compatibility\nimport type { DirectiveNode } from '@core/types';\nimport type { Environment } from '../../env/Environment';\nimport type { EvalResult } from '../../core/interpreter';\nimport { ImportDirectiveEvaluator } from './ImportDirectiveEvaluator';\n\n/**\n * Main entry point for import directive evaluation\n * This function maintains backward compatibility while using the new modular architecture\n */\nexport async function evaluateImport(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  const evaluator = new ImportDirectiveEvaluator(env);\n  return evaluator.evaluateImport(directive, env);\n}","/**\n * Value Combine Utility\n *\n * Implements the += augmented assignment operator for local scopes.\n * Supports: arrays (concat), strings (append), objects (shallow merge)\n */\n\nimport { MlldDirectiveError } from '@core/errors';\nimport { asText, asData, isStructuredValue } from './structured-value';\nimport { toNumber } from '../eval/expression';\n\n/**\n * Check if a value is a plain object (not null, not array, not special type)\n */\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    Object.getPrototypeOf(value) === Object.prototype\n  );\n}\n\n/**\n * Combine values for += operation\n *\n * Rules:\n * - Array += value: appends value (or spreads if value is array)\n * - String += value: appends string representation\n * - Object += object: shallow merge (later wins)\n *\n * @param target - The current value of the local variable\n * @param source - The value to combine with\n * @param targetName - Variable name for error messages\n * @returns The combined value\n */\nexport function combineValues(\n  target: unknown,\n  source: unknown,\n  targetName: string\n): unknown {\n  // Unwrap StructuredValue if needed\n  const targetValue = isStructuredValue(target) ? asData(target) : target;\n  const sourceValue = isStructuredValue(source) ? asData(source) : source;\n\n  // Array: concat\n  if (Array.isArray(targetValue)) {\n    // If source is array, spread it; otherwise wrap as single item\n    const sourceArray = Array.isArray(sourceValue) ? sourceValue : [sourceValue];\n    return [...targetValue, ...sourceArray];\n  }\n\n  // Number: add (numeric)\n  if (typeof targetValue === 'number') {\n    const rhsNumber = toNumber(sourceValue);\n    if (Number.isNaN(rhsNumber)) {\n      throw new MlldDirectiveError(\n        'let',\n        `Cannot += non-numeric value to number @${targetName}.`\n      );\n    }\n    return targetValue + rhsNumber;\n  }\n\n  // String: append\n  if (typeof targetValue === 'string') {\n    return targetValue + asText(sourceValue);\n  }\n\n  // Object: shallow merge\n  if (isPlainObject(targetValue)) {\n    if (!isPlainObject(sourceValue)) {\n      const typeName = Array.isArray(sourceValue) ? 'array' : typeof sourceValue;\n      throw new MlldDirectiveError(\n        'let',\n        `Cannot += non-object to object @${targetName}. ` +\n        `Target is object, source is ${typeName}.`\n      );\n    }\n    return { ...targetValue, ...sourceValue };\n  }\n\n  // Unsupported type\n  const typeName = targetValue === null ? 'null' : typeof targetValue;\n  throw new MlldDirectiveError(\n    'let',\n    `+= requires array, string, or object target. ` +\n    `@${targetName} is ${typeName}.`\n  );\n}\n","import type { WhenNode, WhenSimpleNode, WhenBlockNode, WhenMatchNode, WhenConditionPair, WhenEntry } from '@core/types/when';\nimport type { BaseMlldNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport type { Variable } from '@core/types/variable';\nimport { MlldConditionError } from '@core/errors';\nimport { isWhenSimpleNode, isWhenBlockNode, isWhenMatchNode, isLetAssignment, isAugmentedAssignment, isConditionPair } from '@core/types/when';\nimport { VariableImporter } from './import/VariableImporter';\nimport { evaluate, interpolate } from '../core/interpreter';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { logger } from '@core/utils/logger';\nimport {\n  isTextLike,\n  isArray as isArrayVariable,\n  isObject as isObjectVariable,\n  isCommandResult,\n  isPipelineInput,\n  createSimpleTextVariable,\n  createObjectVariable\n} from '@core/types/variable';\nimport { isStructuredValue, asData, asText, assertStructuredValue } from '../utils/structured-value';\nimport type { LetAssignmentNode, AugmentedAssignmentNode } from '@core/types/when';\nimport { combineValues } from '../utils/value-combine';\nimport { extractVariableValue } from '../utils/variable-resolution';\nimport { MlldWhenExpressionError } from '@core/errors';\n\nconst DENIED_KEYWORD = 'denied';\n\nasync function evaluateAssignmentValue(\n  entry: LetAssignmentNode | AugmentedAssignmentNode,\n  env: Environment\n): Promise<unknown> {\n  let value: unknown;\n  const tail = (entry as any).withClause;\n  let handledByRunEvaluator = false;\n  const wrapperType = (entry as any).meta?.wrapperType;\n  const firstValue = Array.isArray(entry.value) && entry.value.length > 0 ? entry.value[0] : entry.value;\n\n  if (firstValue && typeof firstValue === 'object' && (firstValue as any).type === 'code') {\n    const { evaluateCodeExecution } = await import('./code-execution');\n    const result = await evaluateCodeExecution(firstValue as any, env);\n    value = result.value;\n  }\n\n  if (firstValue && typeof firstValue === 'object' && (firstValue as any).type === 'command') {\n    const commandNode: any = firstValue;\n\n    if (tail) {\n      const { evaluateRun } = await import('./run');\n      const runDirective: any = {\n        type: 'Directive',\n        nodeId: (entry as any).nodeId ? `${(entry as any).nodeId}-run` : undefined,\n        location: entry.location,\n        kind: 'run',\n        subtype: 'runCommand',\n        source: 'command',\n        values: {\n          command: commandNode.command,\n          withClause: tail\n        },\n        raw: {\n          command: Array.isArray(commandNode.command) ? (commandNode.meta?.raw || '') : String(commandNode.command),\n          withClause: tail\n        },\n        meta: {\n          isDataValue: true\n        }\n      };\n      const result = await evaluateRun(runDirective, env);\n      value = result.value;\n      handledByRunEvaluator = true;\n    } else {\n      if (Array.isArray(commandNode.command)) {\n        const interpolatedCommand = await interpolate(\n          commandNode.command,\n          env,\n          InterpolationContext.ShellCommand\n        );\n        value = await env.executeCommand(interpolatedCommand);\n      } else {\n        value = await env.executeCommand(commandNode.command);\n      }\n\n      const { processCommandOutput } = await import('../utils/json-auto-parser');\n      value = processCommandOutput(value);\n    }\n  }\n\n  if (wrapperType && Array.isArray(entry.value)) {\n    if (wrapperType === 'tripleColon') {\n      value = entry.value;\n    } else if (\n      wrapperType === 'backtick' &&\n      entry.value.length === 1 &&\n      (entry.value[0] as any).type === 'Text'\n    ) {\n      value = (entry.value[0] as any).content;\n    } else {\n      value = await interpolate(entry.value, env);\n    }\n  }\n\n  const isRawPrimitive = firstValue === null ||\n    typeof firstValue === 'number' ||\n    typeof firstValue === 'boolean' ||\n    (typeof firstValue === 'string' && !('type' in (firstValue as any)));\n\n  if (value === undefined) {\n    if (isRawPrimitive) {\n      value = (entry.value as any[]).length === 1 ? firstValue : entry.value;\n    } else {\n      const valueResult = await evaluate(entry.value, env, { isExpression: true });\n      value = valueResult.value;\n    }\n  }\n\n  if (tail && !handledByRunEvaluator) {\n    const { processPipeline } = await import('./pipeline/unified-processor');\n    value = await processPipeline({\n      value,\n      env,\n      node: entry,\n      identifier: entry.identifier,\n      location: entry.location\n    });\n  }\n\n  return value;\n}\n\n/**\n * Helper to evaluate a let assignment and return updated environment\n */\nexport async function evaluateLetAssignment(\n  entry: LetAssignmentNode,\n  env: Environment\n): Promise<Environment> {\n  const value = await evaluateAssignmentValue(entry, env);\n\n  const importer = new VariableImporter();\n  const variable = importer.createVariableFromValue(\n    entry.identifier,\n    value,\n    'let',\n    undefined,\n    { env }\n  );\n  const newEnv = env.createChild();\n  newEnv.setVariable(entry.identifier, variable);\n  return newEnv;\n}\n\n/**\n * Helper to evaluate an augmented assignment and return updated environment\n */\nexport async function evaluateAugmentedAssignment(\n  entry: AugmentedAssignmentNode,\n  env: Environment\n): Promise<Environment> {\n  const isolationRoot = findIsolationRoot(env);\n  // Get existing variable - must exist\n  const existing = env.getVariable(entry.identifier);\n  if (!existing) {\n    throw new MlldWhenExpressionError(\n      `Cannot use += on undefined variable @${entry.identifier}. ` +\n      `Use \"let @${entry.identifier} = ...\" first.`,\n      entry.location\n    );\n  }\n\n  if (isolationRoot) {\n    const owner = findVariableOwner(env, entry.identifier);\n    if (!owner || !isDescendantEnvironment(owner, isolationRoot)) {\n      throw new MlldWhenExpressionError(\n        `Parallel for block cannot mutate outer variable @${entry.identifier}.`,\n        entry.location\n      );\n    }\n  }\n\n  // Evaluate the RHS value\n  const rhsValue = await evaluateAssignmentValue(entry, env);\n\n  // Get current value of the variable\n  const existingValue = await extractVariableValue(existing, env);\n\n  // Combine values using the += semantics\n  const combined = combineValues(existingValue, rhsValue, entry.identifier);\n\n  // Update variable in local scope (use updateVariable to bypass redefinition check)\n  const importer = new VariableImporter();\n  const updatedVar = importer.createVariableFromValue(\n    entry.identifier,\n    combined,\n    'let',\n    undefined,\n    { env }\n  );\n\n  // Update the variable in the owning environment (current scope or ancestor)\n  let targetEnv: Environment | undefined = env;\n  while (targetEnv && !targetEnv.getCurrentVariables().has(entry.identifier)) {\n    targetEnv = targetEnv.getParent();\n  }\n  (targetEnv ?? env).updateVariable(entry.identifier, updatedVar);\n  return env;\n}\n\nfunction findIsolationRoot(env: Environment): Environment | undefined {\n  let current: Environment | undefined = env;\n  while (current) {\n    if ((current as any).__parallelIsolationRoot === current) {\n      return current;\n    }\n    current = current.getParent();\n  }\n  return undefined;\n}\n\nfunction findVariableOwner(env: Environment, name: string): Environment | undefined {\n  let current: Environment | undefined = env;\n  while (current) {\n    if (current.getCurrentVariables().has(name)) return current;\n    current = current.getParent();\n  }\n  return undefined;\n}\n\nfunction isDescendantEnvironment(env: Environment, ancestor: Environment): boolean {\n  let current: Environment | undefined = env;\n  while (current) {\n    if (current === ancestor) return true;\n    current = current.getParent();\n  }\n  return false;\n}\n\n/**\n * Compares two values according to mlld's when comparison rules\n * WHY: mlld has specific comparison semantics that differ from JavaScript's ===.\n * We support string-boolean comparisons (\"true\" === true), null/undefined equality,\n * and truthy/falsy evaluation when comparing against boolean literals.\n * GOTCHA: String comparison is case-sensitive. \"True\" !== true, only \"true\" === true.\n * Type coercion is limited to specific cases to avoid surprising behavior.\n * CONTEXT: Used by all when directive forms (simple, switch, block) to evaluate\n * conditions consistently across the language.\n */\nasync function compareValues(expressionValue: any, conditionValue: any, env: Environment): Promise<boolean> {\n  /**\n   * Extract Variable values for equality comparison\n   * WHY: Equality operations need raw values because comparisons work on\n   *      primitive types, not Variable wrapper objects\n   */\n  const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n  expressionValue = await resolveValue(expressionValue, env, ResolutionContext.Equality);\n  conditionValue = await resolveValue(conditionValue, env, ResolutionContext.Equality);\n  \n  // Both null/undefined\n  if ((expressionValue === null || expressionValue === undefined) &&\n      (conditionValue === null || conditionValue === undefined)) {\n    return true;\n  }\n  // String comparison - case sensitive\n  else if (typeof expressionValue === 'string' && typeof conditionValue === 'string') {\n    return expressionValue === conditionValue;\n  }\n  // Boolean comparison\n  else if (typeof expressionValue === 'boolean' && typeof conditionValue === 'boolean') {\n    return expressionValue === conditionValue;\n  }\n  // Number comparison\n  else if (typeof expressionValue === 'number' && typeof conditionValue === 'number') {\n    return expressionValue === conditionValue;\n  }\n  // String-boolean comparison: \"true\"/\"false\" matches true/false\n  else if (typeof expressionValue === 'string' && typeof conditionValue === 'boolean') {\n    return (expressionValue === 'true' && conditionValue === true) ||\n           (expressionValue === 'false' && conditionValue === false);\n  }\n  else if (typeof expressionValue === 'boolean' && typeof conditionValue === 'string') {\n    return (expressionValue === true && conditionValue === 'true') ||\n           (expressionValue === false && conditionValue === 'false');\n  }\n  // Truthy comparison - if condition is boolean literal\n  else if (typeof conditionValue === 'boolean') {\n    return isTruthy(expressionValue) === conditionValue;\n  }\n  // Direct equality for other cases\n  else {\n    return expressionValue === conditionValue;\n  }\n}\n\nfunction preview(value: unknown, max = 60): string {\n  try {\n    if (typeof value === 'string') return value.length > max ? value.slice(0, max) + '…' : value;\n    if (typeof value === 'number' || typeof value === 'boolean' || value === null || value === undefined) return String(value);\n    return JSON.stringify(value)?.slice(0, max) + (JSON.stringify(value)?.length! > max ? '…' : '');\n  } catch {\n    return String(value);\n  }\n}\n\n/**\n * Evaluates a @when directive.\n * Handles simple, switch, and block forms.\n */\nexport async function evaluateWhen(\n  node: WhenNode,\n  env: Environment\n): Promise<EvalResult> {\n  \n  if (isWhenSimpleNode(node)) {\n    return evaluateWhenSimple(node, env);\n  } else if (isWhenMatchNode(node)) {\n    return evaluateWhenMatch(node, env);\n  } else if (isWhenBlockNode(node)) {\n    return evaluateWhenBlock(node, env);\n  }\n  \n  throw new MlldConditionError(\n    `Unknown when node subtype: ${(node as any).subtype}`,\n    undefined,\n    node.location\n  );\n}\n\n/**\n * Evaluates a simple when directive: @when <condition> => <action>\n */\nasync function evaluateWhenSimple(\n  node: WhenSimpleNode,\n  env: Environment\n): Promise<EvalResult> {\n  const conditionResult = await evaluateCondition(node.values.condition, env);\n  \n  if (process.env.DEBUG_WHEN) {\n    logger.debug('When condition result:', { conditionResult });\n  }\n  \n  if (conditionResult) {\n    // Execute the action if condition is true\n    const result = await evaluate(node.values.action, env);\n    return result;\n  }\n  \n  // Return empty string if condition is false\n  return { value: '', env };\n}\n\n/**\n * Evaluates a match when directive: @when <expression>: [value => action, ...]\n * Evaluates the expression once and executes actions for all matching conditions\n */\nasync function evaluateWhenMatch(\n  node: WhenMatchNode,\n  env: Environment\n): Promise<EvalResult> {\n  // Validate none placement\n  validateNonePlacement(node.values.conditions);\n  \n  // Evaluate the expression once without producing output\n  // For simple text nodes, extract the value directly\n  let expressionValue: any;\n  if (node.values.expression.length === 1 && node.values.expression[0].type === 'Text') {\n    expressionValue = node.values.expression[0].content;\n  } else {\n    const expressionResult = await evaluate(node.values.expression, env);\n    expressionValue = expressionResult.value;\n  }\n  \n  // Create a child environment for the switch block\n  let childEnv = env.createChild();\n\n  // Process let and augmented assignments first to build up the environment\n  for (const entry of node.values.conditions) {\n    if (isLetAssignment(entry)) {\n      childEnv = await evaluateLetAssignment(entry, childEnv);\n    } else if (isAugmentedAssignment(entry)) {\n      childEnv = await evaluateAugmentedAssignment(entry, childEnv);\n    }\n  }\n\n  // Filter to only condition pairs for iteration\n  const conditionPairs = node.values.conditions.filter(isConditionPair);\n\n  // Track if any non-none condition matched\n  let anyNonNoneMatched = false;\n\n  try {\n    // First pass: Check each non-none condition value against the expression result\n    for (const pair of conditionPairs) {\n      // Skip none conditions in first pass\n      if (pair.condition.length === 1 && isNoneCondition(pair.condition[0])) {\n        continue;\n      }\n      // Check if this is a negation node\n      let isNegated = false;\n      let actualCondition = pair.condition;\n      \n      if (actualCondition.length === 1 && actualCondition[0].type === 'UnaryExpression') {\n        const unaryNode = actualCondition[0] as any;\n        if (unaryNode.operator === '!') {\n          isNegated = true;\n          actualCondition = [unaryNode.operand];\n        }\n      }\n      \n      // Evaluate the condition value without producing output\n      // For simple text nodes, extract the value directly\n      let conditionValue: any;\n      if (actualCondition.length === 1 && actualCondition[0].type === 'Text') {\n        conditionValue = actualCondition[0].content;\n      } else if (actualCondition.length === 1 && actualCondition[0].type === 'ExecInvocation') {\n        // Handle ExecInvocation as a condition\n        const execResult = await evaluateCondition(actualCondition, childEnv);\n        // For exec invocations, we want the boolean result\n        conditionValue = execResult;\n      } else {\n        // For more complex conditions, evaluate them\n        const conditionResult = await evaluate(actualCondition, childEnv);\n        conditionValue = conditionResult.value;\n      }\n      \n      // Compare values using shared logic\n      let matches = await compareValues(expressionValue, conditionValue, childEnv);\n      \n      // Apply negation if needed\n      if (isNegated) {\n        matches = !matches;\n      }\n      \n      if (matches) {\n        anyNonNoneMatched = true;\n        if (pair.action) {\n          // Handle action which might be an array of nodes\n          const actionNodes = Array.isArray(pair.action) ? pair.action : [pair.action];\n          for (const actionNode of actionNodes) {\n            await evaluate(actionNode, childEnv);\n          }\n          // Merge child environment nodes back to parent\n          env.mergeChild(childEnv);\n          // For @when, we don't want to propagate the action's output value to the document\n          // The action should have already done what it needs to do (like @output writing to a file)\n          return { value: '', env };\n        }\n      }\n    }\n    \n    // Second pass: Handle none conditions if no non-none conditions matched\n    if (!anyNonNoneMatched) {\n      for (const pair of conditionPairs) {\n        // Only process none conditions in second pass\n        if (pair.condition.length === 1 && isNoneCondition(pair.condition[0])) {\n          if (pair.action) {\n            // Handle action which might be an array of nodes\n            const actionNodes = Array.isArray(pair.action) ? pair.action : [pair.action];\n            for (const actionNode of actionNodes) {\n              await evaluate(actionNode, childEnv);\n            }\n            // Merge child environment nodes back to parent\n            env.mergeChild(childEnv);\n            return { value: '', env };\n          }\n        }\n      }\n    }\n    \n    // No match found\n    return { value: '', env };\n  } finally {\n    // Child environment goes out of scope\n  }\n}\n\n/**\n * Evaluates a block when directive: @when <var> <modifier>: [...]\n * WHY: Block forms enable different conditional evaluation strategies - first match\n * (classic switch), all conditions (AND logic), any condition (OR logic), or\n * independent evaluation of each condition.\n * GOTCHA: Default behavior (no modifier) differs based on presence of block action:\n *   - With action: acts like 'all:' (ALL conditions must match)\n *   - Without action: executes ALL matching individual actions\n * CONTEXT: Child environment ensures variable definitions inside when blocks are\n * scoped locally, preventing pollution of parent scope.\n */\nasync function evaluateWhenBlock(\n  node: WhenBlockNode,\n  env: Environment\n): Promise<EvalResult> {\n  const modifier = node.meta.modifier;\n\n  // For comparison-based modifiers (first, any, all), we need the expression to compare against\n  let expressionNodes: BaseMlldNode[] | undefined;\n\n  // Store variable value if specified\n  let originalValue: any;\n  let variableName: string | undefined;\n\n\n  if (node.values.variable && node.meta.hasVariable) {\n    // The variable nodes contain the expression to evaluate\n    expressionNodes = node.values.variable;\n\n\n    // Extract variable name from the VariableReference node\n    if (expressionNodes.length === 1 && expressionNodes[0].type === 'VariableReference') {\n      const varRef = expressionNodes[0] as any;\n      variableName = varRef.identifier;\n\n\n      if (variableName) {\n        // Store original value to restore later\n        originalValue = env.hasVariable(variableName) ? env.getVariable(variableName) : undefined;\n      }\n    }\n  }\n\n  // Create a child environment for the when block\n  let childEnv = env.createChild();\n\n  // Process let and augmented assignments first to build up the environment\n  for (const entry of node.values.conditions) {\n    if (isLetAssignment(entry)) {\n      childEnv = await evaluateLetAssignment(entry, childEnv);\n    } else if (isAugmentedAssignment(entry)) {\n      childEnv = await evaluateAugmentedAssignment(entry, childEnv);\n    }\n  }\n\n  // Filter to only condition pairs for evaluation\n  const conditions = node.values.conditions.filter(isConditionPair);\n  \n  try {\n    let result: EvalResult;\n    \n    switch (modifier) {\n      case 'first':\n        result = await evaluateFirstMatch(conditions, childEnv, variableName, expressionNodes);\n        break;\n        \n      case 'all':\n        // 'all' modifier has been removed - this should never be reached\n        throw new MlldConditionError(\n          'The \\'all\\' modifier has been removed. Use the && operator instead.\\n' +\n          'Example: /when (@cond1 && @cond2) => action',\n          'all',\n          node.location\n        );\n\n      case 'any':\n        // 'any' modifier has been removed - this should never be reached\n        throw new MlldConditionError(\n          'The \\'any\\' modifier has been removed. Use the || operator instead.\\n' +\n          'Example: /when (@cond1 || @cond2) => action',\n          'any',\n          node.location\n        );\n        \n      case 'default':\n        // Bare @when behavior depends on whether there's a block action\n        if (node.values.action) {\n          // With block action: behave like 'all:' - execute action if ALL conditions are true\n          result = await evaluateAllMatches(conditions, childEnv, variableName, node.values.action);\n        } else {\n          // Without block action: execute all matching individual actions\n          result = await evaluateAllMatches(conditions, childEnv, variableName);\n        }\n        break;\n        \n      default:\n        throw new MlldConditionError(\n          `Invalid when modifier: ${modifier}`,\n          modifier as 'first' | 'all' | 'any' | 'default',\n          node.location\n        );\n    }\n    \n    // Merge child environment nodes back to parent\n    // This ensures output nodes created by actions are preserved\n    if (process.env.DEBUG_WHEN) {\n      logger.debug('Before merge:', {\n        parentNodes: env.nodes.length,\n        childNodes: childEnv.nodes.length,\n        childInitialCount: childEnv.initialNodeCount,\n        resultEnvNodes: result.env.nodes.length\n      });\n    }\n    \n    // The result.env contains the updated environment from the evaluation\n    // We need to merge from result.env, not childEnv\n    env.mergeChild(result.env);\n    \n    if (process.env.DEBUG_WHEN) {\n      logger.debug('After merge:', {\n        parentEnvNodes: env.nodes.length,\n        resultValue: result.value\n      });\n    }\n    \n    // Return the result with the updated parent environment\n    return { value: result.value, env };\n  } finally {\n    // Child environment goes out of scope\n  }\n}\n\n/**\n * Evaluates conditions using 'first' modifier - executes first matching condition\n * WHY: Implements classic switch-case behavior where only the first matching branch\n * executes, providing mutual exclusion between conditions.\n * GOTCHA: Conditions are evaluated in order, so put more specific conditions first.\n * Unlike switch statements, there's no fallthrough - only one action executes.\n * CONTEXT: Useful for state machines, routing logic, and mutually exclusive branches.\n */\nasync function evaluateFirstMatch(\n  conditions: WhenConditionPair[],\n  env: Environment,\n  variableName?: string,\n  expressionNodes?: BaseMlldNode[]\n): Promise<EvalResult> {\n  // Validate none placement\n  validateNonePlacement(conditions);\n  \n  // If we have expression nodes, evaluate them to get the value to compare against\n  let expressionValue: any;\n  if (expressionNodes && expressionNodes.length > 0) {\n    \n    if (expressionNodes.length === 1 && expressionNodes[0].type === 'Text') {\n      expressionValue = (expressionNodes[0] as any).content;\n    } else if (expressionNodes.length === 1 && expressionNodes[0].type === 'VariableReference') {\n      // For variable references, get the actual value, not the output\n      const varRef = expressionNodes[0] as any;\n      const variable = env.getVariable(varRef.identifier);\n      if (variable) {\n        expressionValue = variable.value;\n      }\n      \n    } else {\n      const expressionResult = await evaluate(expressionNodes, env);\n      expressionValue = expressionResult.value;\n      \n    }\n  }\n  \n  // Track if any non-none condition matched\n  let anyNonNoneMatched = false;\n  \n  for (const pair of conditions) {\n    // Check if this is a none condition\n    if (pair.condition.length === 1 && isNoneCondition(pair.condition[0])) {\n      // For 'first' mode, none acts as a default case\n      if (!anyNonNoneMatched) {\n        // Execute the action for 'none'\n        if (pair.action) {\n          const actionNodes = Array.isArray(pair.action) ? pair.action : [pair.action];\n          for (const actionNode of actionNodes) {\n            await evaluate(actionNode, env);\n          }\n        }\n        return { value: '', env };\n      }\n      continue;\n    }\n    let matches = false;\n    \n    if (expressionValue !== undefined) {\n      // Compare expression value against condition value (like switch mode)\n      let conditionValue: any;\n      \n      // Check for negation\n      let isNegated = false;\n      let actualCondition = pair.condition;\n      \n      if (actualCondition.length === 1 && actualCondition[0].type === 'UnaryExpression') {\n        const unaryNode = actualCondition[0] as any;\n        if (unaryNode.operator === '!') {\n          isNegated = true;\n          actualCondition = [unaryNode.operand];\n        }\n      }\n      \n      // Evaluate the condition value\n      if (actualCondition.length === 1 && actualCondition[0].type === 'Text') {\n        conditionValue = (actualCondition[0] as any).content;\n      } else if (actualCondition.length === 1 && actualCondition[0].type === 'ExecInvocation') {\n        // Handle ExecInvocation as a condition\n        const execResult = await evaluateCondition(actualCondition, env);\n        // For exec invocations, we want the boolean result\n        conditionValue = execResult;\n      } else {\n        const conditionResult = await evaluate(actualCondition, env);\n        conditionValue = conditionResult.value;\n      }\n      \n      // Compare values using shared logic\n      matches = await compareValues(expressionValue, conditionValue, env);\n      \n      \n      // Apply negation if needed\n      if (isNegated) {\n        matches = !matches;\n      }\n    } else {\n      // No expression value, fall back to truthiness evaluation\n      matches = await evaluateCondition(pair.condition, env, variableName);\n    }\n    \n    if (matches) {\n      anyNonNoneMatched = true;\n      if (pair.action) {\n        const result = await evaluate(pair.action, env);\n        // The action has already added its output nodes during evaluation\n        // Just return the result\n        return result;\n      }\n      return { value: '', env };\n    }\n  }\n  \n  return { value: '', env };\n}\n\n/**\n * Evaluates conditions using 'all' modifier\n * WHY: Supports two distinct use cases - AND logic (with block action) where ALL\n * conditions must be true, or independent evaluation (without block action) where\n * each true condition's action executes.\n * GOTCHA: Behavior changes based on presence of block action:\n *   - With block action: ALL conditions must be true (AND logic)\n *   - Without block action: Each true condition executes independently\n * Cannot mix block action with individual condition actions.\n * CONTEXT: AND logic useful for validation checks, independent evaluation useful\n * for applying multiple transformations or checks.\n */\nasync function evaluateAllMatches(\n  conditions: WhenConditionPair[],\n  env: Environment,\n  variableName?: string,\n  blockAction?: BaseMlldNode[]\n): Promise<EvalResult> {\n  // Validate none placement\n  validateNonePlacement(conditions);\n  \n  // If we have a block action, check if ALL conditions are true first\n  if (blockAction) {\n    // Check for invalid syntax: all: with block action cannot have individual actions\n    if (conditions.some(pair => pair.action)) {\n      throw new MlldConditionError(\n        'Invalid @when syntax: \\'all:\\' modifier cannot have individual actions for conditions when using a block action. Use either individual actions OR a block action after the conditions: @when all: [...] => @add \"action\"',\n        'all',\n        undefined\n      );\n    }\n    \n    let allMatch = true;\n    \n    for (const pair of conditions) {\n      // Skip none conditions in all: block mode\n      if (pair.condition.length === 1 && isNoneCondition(pair.condition[0])) {\n        continue;\n      }\n      \n      const conditionResult = await evaluateCondition(pair.condition, env, variableName);\n      \n      if (!conditionResult) {\n        allMatch = false;\n        break;\n      }\n    }\n    \n    // Execute block action only if all conditions matched\n    if (allMatch) {\n      if (process.env.DEBUG_WHEN) {\n        logger.debug('Executing block action', { envNodesBefore: env.nodes.length });\n      }\n      const result = await evaluate(blockAction, env);\n      if (process.env.DEBUG_WHEN) {\n        logger.debug('Block action completed', {\n          result,\n          envNodesAfter: env.nodes.length\n        });\n      }\n      return result;\n    }\n    \n    return { value: '', env };\n  }\n  \n  // Otherwise, execute individual actions for each true condition\n  const results: string[] = [];\n  let anyNonNoneMatched = false;\n  \n  // First pass: evaluate non-none conditions\n  for (const pair of conditions) {\n    // Skip none conditions in first pass\n    if (pair.condition.length === 1 && isNoneCondition(pair.condition[0])) {\n      continue;\n    }\n    \n    const conditionResult = await evaluateCondition(pair.condition, env, variableName);\n    \n    if (conditionResult) {\n      anyNonNoneMatched = true;\n      if (pair.action) {\n        const actionResult = await evaluate(pair.action, env);\n        if (actionResult.value) {\n          results.push(String(actionResult.value));\n        }\n      }\n    }\n  }\n  \n  // Second pass: evaluate none conditions if no non-none matched\n  if (!anyNonNoneMatched) {\n    for (const pair of conditions) {\n      // Only process none conditions in second pass\n      if (pair.condition.length === 1 && isNoneCondition(pair.condition[0])) {\n        if (pair.action) {\n          const actionResult = await evaluate(pair.action, env);\n          if (actionResult.value) {\n            results.push(String(actionResult.value));\n          }\n        }\n      }\n    }\n  }\n  \n  // Join results with newlines, but only if we have multiple results\n  // If single result, don't add trailing newline\n  return { value: results.length > 1 ? results.join('\\n') : results.join(''), env };\n}\n\n/**\n * Evaluates conditions using 'any' modifier - executes action if any condition matches\n * WHY: Implements OR logic where the block action executes if at least one condition\n * is true, useful for triggering actions based on multiple possible triggers.\n * GOTCHA: Requires a block action - individual condition actions are not allowed.\n * All conditions are evaluated (no short-circuit) to ensure consistent behavior.\n * CONTEXT: Useful for validation warnings, fallback logic, or actions that should\n * trigger on any of several conditions.\n */\nasync function evaluateAnyMatch(\n  conditions: WhenConditionPair[],\n  env: Environment,\n  variableName?: string,\n  blockAction?: BaseMlldNode[]\n): Promise<EvalResult> {\n  // Check for invalid syntax: any: cannot have individual actions\n  if (conditions.some(pair => pair.action)) {\n    throw new MlldConditionError(\n      'Invalid @when syntax: \\'any:\\' modifier cannot have individual actions for conditions. Use a block action after the conditions instead: @when any: [...] => @add \"action\"',\n      'any',\n      undefined\n    );\n  }\n  \n  // First check if any condition is true\n  let anyMatch = false;\n  \n  for (const pair of conditions) {\n    const conditionResult = await evaluateCondition(pair.condition, env, variableName);\n    \n    if (conditionResult) {\n      anyMatch = true;\n      \n      // Set variable to the matching condition's value if specified\n      if (variableName && pair.condition.length > 0) {\n        const conditionResult = await evaluate(pair.condition, env);\n        const conditionValue = conditionResult.value;\n        \n        // Create a variable from the condition value\n        const variable = typeof conditionValue === 'string' ?\n          createSimpleTextVariable(variableName, conditionValue, {\n            mx: {\n              source: {\n                directive: 'var',\n                syntax: 'quoted',\n                hasInterpolation: false,\n                isMultiLine: false\n              }\n            }\n          }) :\n          createObjectVariable(variableName, conditionValue, {\n            mx: {\n              source: {\n                directive: 'var',\n                syntax: 'object',\n                hasInterpolation: false,\n                isMultiLine: false\n              }\n            }\n          });\n        env.setVariable(variableName, variable);\n      }\n      \n      break;\n    }\n  }\n  \n  // Execute block action if any condition matched\n  if (anyMatch && blockAction) {\n    return await evaluate(blockAction, env);\n  }\n  \n  return { value: '', env };\n}\n\n/**\n * Evaluates a condition expression to a boolean value\n */\nexport async function evaluateCondition(\n  condition: BaseMlldNode[],\n  env: Environment,\n  variableName?: string\n): Promise<boolean> {\n  const deniedContext = env.getContextManager().peekDeniedContext();\n  const deniedState = Boolean(deniedContext?.denied);\n\n  // Handle new WhenCondition wrapper nodes from unified expressions\n  if (condition.length === 1 && condition[0].type === 'WhenCondition') {\n    const whenCondition = condition[0] as any;\n    const expression = whenCondition.expression;\n    \n    // Evaluate the wrapped expression\n    const result = await evaluateCondition([expression], env, variableName);\n    \n    // Apply negation if specified in the wrapper\n    return whenCondition.negated ? !result : result;\n  }\n  \n  // Check if this is a negation node (UnaryExpression with operator '!')\n  if (condition.length === 1 && condition[0].type === 'UnaryExpression') {\n    const unaryNode = condition[0] as any;\n    if (unaryNode.operator === '!') {\n      if (isDeniedLiteralNode(unaryNode.operand)) {\n        return !deniedState;\n      }\n      const innerCondition = [unaryNode.operand];\n      \n      // Evaluate the inner condition and negate the result\n      const innerResult = await evaluateCondition(innerCondition, env, variableName);\n      return !innerResult;\n    }\n  }\n\n  if (condition.length === 1 && isDeniedLiteralNode(condition[0])) {\n    return deniedState;\n  }\n  \n  // Check if this is an expression node (BinaryExpression, TernaryExpression, UnaryExpression)\n  if (condition.length === 1) {\n    const node = condition[0];\n    if (node.type === 'BinaryExpression' || node.type === 'TernaryExpression' || node.type === 'UnaryExpression') {\n      const { evaluateUnifiedExpression } = await import('./expressions');\n      let resultValue: unknown;\n      try {\n        const expressionResult = await evaluateUnifiedExpression(node as any, env);\n        resultValue = expressionResult.value;\n      } catch (err) {\n        // Add operator and operand previews for helpful diagnostics\n        const op = (node as any).operator || (node as any).test?.type || node.type;\n        const lhs = (node as any).left ?? (node as any).argument ?? (node as any).test;\n        const rhs = (node as any).right ?? (node as any).consequent;\n        const message = `Failed to evaluate condition expression (${op}).`;\n        throw new MlldConditionError(message, undefined, node.location, {\n          originalError: err as Error,\n          errors: [\n            {\n              type: 'expression',\n              count: 1,\n              firstExample: {\n                conditionIndex: 0,\n                message: `op=${op}, left=${preview(lhs)}, right=${preview(rhs)}`\n              }\n            }\n          ]\n        } as any);\n      }\n      const truthy = isTruthy(resultValue);\n      if (process.env.MLLD_DEBUG === 'true') {\n        try {\n          console.error('[evaluateCondition] expression node result:', {\n            nodeType: node.type,\n            result: resultValue,\n            truthy\n          });\n        } catch {}\n      }\n      return truthy;\n    }\n  }\n  \n  // Check if this is an ExecInvocation node\n  if (condition.length === 1 && condition[0].type === 'ExecInvocation') {\n    const execNode = condition[0] as any;\n    \n    // Import the exec invocation evaluator\n    const { evaluateExecInvocation } = await import('./exec-invocation');\n    \n    // Create a child environment for execution\n    const childEnv = env.createChild();\n    \n    // If we have a comparison variable, pass it as the first implicit argument\n    if (variableName) {\n      const variable = env.getVariable(variableName);\n      if (variable) {\n        // Modify the ExecInvocation to include the comparison value as the first argument\n        const modifiedExecNode = {\n          ...execNode,\n          commandRef: {\n            ...execNode.commandRef,\n            args: [\n              // Insert the variable's value as the first argument\n              {\n                type: 'VariableReference',\n                identifier: variableName,\n                nodeId: 'implicit-when-arg',\n                valueType: 'variable'\n              },\n              ...(execNode.commandRef.args || [])\n            ]\n          }\n        };\n        \n    // Execute the modified invocation\n    let result: any;\n    try {\n      result = await evaluateExecInvocation(modifiedExecNode, childEnv);\n    } catch (err) {\n      const name = modifiedExecNode?.commandRef?.name || 'exec';\n      throw new MlldConditionError(\n        `Failed to evaluate function in condition: ${name}`,\n        undefined,\n        (modifiedExecNode as any).location,\n        { originalError: err as Error } as any\n      );\n    }\n        \n        // Check the result for truthiness\n        if (result.stdout !== undefined) {\n          // Command execution result\n          if (result.exitCode !== undefined && result.exitCode !== 0) {\n            return false;\n          }\n          if (result.value !== undefined && result.value !== result.stdout) {\n            /**\n             * Extract Variable value for truthiness evaluation\n             * WHY: Truthiness checks need raw values because boolean logic operates on\n             *      primitive types, not Variable metadata\n             */\n            const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n            const finalValue = await resolveValue(result.value, childEnv, ResolutionContext.Truthiness);\n            return isTruthy(finalValue);\n          }\n          return isTruthy(result.stdout.trim());\n        }\n        \n        /**\n         * Extract Variable value for truthiness evaluation\n         * WHY: Truthiness checks need raw values because boolean logic operates on\n         *      primitive types, not Variable metadata\n         */\n        const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n        const finalValue = await resolveValue(result.value, childEnv, ResolutionContext.Truthiness);\n        return isTruthy(finalValue);\n      }\n    }\n    \n    // No comparison variable - just execute the function and check its result\n    let result: any;\n    try {\n      result = await evaluateExecInvocation(execNode, childEnv);\n    } catch (err) {\n      const name = (execNode as any)?.commandRef?.name || 'exec';\n      throw new MlldConditionError(\n        `Failed to evaluate function in condition: ${name}`,\n        undefined,\n        (execNode as any).location,\n        { originalError: err as Error } as any\n      );\n    }\n    \n    // Check the result for truthiness\n    if (result.stdout !== undefined) {\n      // Command execution result\n      if (result.exitCode !== undefined && result.exitCode !== 0) {\n        return false;\n      }\n      if (result.value !== undefined && result.value !== result.stdout) {\n        const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n        const finalValue = await resolveValue(result.value, childEnv, ResolutionContext.Truthiness);\n        return isTruthy(finalValue);\n      }\n      return isTruthy(result.stdout.trim());\n    }\n    \n    const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n    const finalValue = await resolveValue(result.value, childEnv, ResolutionContext.Truthiness);\n    return isTruthy(finalValue);\n  }\n  \n  // Create a child environment for condition evaluation\n  const childEnv = env.createChild();\n  \n  // If a variable name is specified, set it to the condition value for evaluation\n  if (variableName) {\n    const variable = env.getVariable(variableName);\n    if (variable) {\n      // Set the _whenValue context for built-in functions\n      childEnv.setVariable('_whenValue', variable);\n    }\n  }\n  \n  if (process.env.DEBUG_WHEN) {\n    logger.debug('Evaluating condition:', { condition });\n  }\n  \n  // Evaluate the condition with condition and expression context\n  let result: any;\n  try {\n    result = await evaluate(condition, childEnv, { isCondition: true, isExpression: true });\n  } catch (err) {\n    throw new MlldConditionError(\n      'Failed to evaluate condition value',\n      undefined,\n      (condition[0] as any)?.location,\n      { originalError: err as Error } as any\n    );\n  }\n  \n  if (process.env.DEBUG_WHEN) {\n    logger.debug('Condition evaluation result:', { result });\n  }\n  \n  // If we have a variable to compare against\n  if (variableName && childEnv.hasVariable('_whenValue')) {\n    const whenValue = childEnv.getVariable('_whenValue');\n    \n    // Check if the condition is an executable (function call)\n    if (result.value && typeof result.value === 'object' && result.value.type === 'executable') {\n      // The executable should have already been evaluated with _whenValue as context\n      // Just check its boolean result\n      const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n      const finalValue = await resolveValue(result.value, childEnv, ResolutionContext.Truthiness);\n      return isTruthy(finalValue);\n    }\n    \n    // Get the actual value from the variable\n    let actualValue: any;\n    if (whenValue && typeof whenValue === 'object' && 'value' in whenValue) {\n      actualValue = whenValue.value;\n    } else {\n      actualValue = whenValue;\n    }\n    \n    // Compare the variable value with the condition value\n    return compareValues(actualValue, result.value, childEnv);\n  }\n  \n  // For command execution results, check stdout or exit code\n  if (result.stdout !== undefined) {\n    // This is a command execution result\n    // First check exit code - 0 is true, non-zero is false\n    if (result.exitCode !== undefined && result.exitCode !== 0) {\n      return false;\n    }\n    // If we have a parsed value (from exec functions with return values), use that\n    // This handles the case where JSON stringified empty string '\"\"' should be falsy\n    if (result.value !== undefined && result.value !== result.stdout) {\n      /**\n       * Extract Variable value for truthiness evaluation\n       * WHY: Truthiness checks need raw values because boolean logic operates on\n       *      primitive types, not Variable metadata\n       */\n      const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n      const finalValue = await resolveValue(result.value, childEnv, ResolutionContext.Truthiness);\n      return isTruthy(finalValue);\n    }\n    // Otherwise check stdout - trim whitespace\n    const trimmedStdout = result.stdout.trim();\n    if (process.env.DEBUG_WHEN) {\n      logger.debug('Trimmed stdout for truthiness:', { trimmedStdout });\n    }\n    return isTruthy(trimmedStdout);\n  }\n  \n  /**\n   * Extract Variable value for truthiness evaluation\n   * WHY: Truthiness checks need raw values because boolean logic operates on\n   *      primitive types, not Variable metadata\n   */\n  const { resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n  const finalValue = await resolveValue(result.value, childEnv, ResolutionContext.Truthiness);\n  \n  // Convert result to boolean\n  return isTruthy(finalValue);\n}\n\nfunction isDeniedLiteralNode(node: BaseMlldNode | undefined): boolean {\n  if (!node) {\n    return false;\n  }\n  if (node.type === 'Literal' && typeof (node as any).value === 'string') {\n    return (node as any).value.toLowerCase() === DENIED_KEYWORD;\n  }\n  if (node.type === 'Text' && typeof (node as any).content === 'string') {\n    return (node as any).content.trim().toLowerCase() === DENIED_KEYWORD;\n  }\n  if (\n    node.type === 'VariableReference' &&\n    typeof (node as any).identifier === 'string' &&\n    (node as any).identifier.toLowerCase() === DENIED_KEYWORD\n  ) {\n    return true;\n  }\n  return false;\n}\n\nfunction isDeniedField(field: any): boolean {\n  if (!field) {\n    return false;\n  }\n  if (typeof field.name === 'string' && field.name.toLowerCase() === DENIED_KEYWORD) {\n    return true;\n  }\n  if (typeof field.identifier === 'string' && field.identifier.toLowerCase() === DENIED_KEYWORD) {\n    return true;\n  }\n  return false;\n}\n\nexport function conditionTargetsDenied(condition: BaseMlldNode[]): boolean {\n  const visited = new Set<BaseMlldNode>();\n  const stack = [...condition];\n\n  while (stack.length > 0) {\n    const node = stack.pop();\n    if (!node || typeof node !== 'object') {\n      continue;\n    }\n    if (visited.has(node)) {\n      continue;\n    }\n    visited.add(node);\n\n    if (isDeniedLiteralNode(node)) {\n      return true;\n    }\n\n    if ((node as any).type === 'VariableReference') {\n      const identifier = typeof (node as any).identifier === 'string'\n        ? (node as any).identifier.toLowerCase()\n        : '';\n      if (identifier === DENIED_KEYWORD) {\n        return true;\n      }\n      if (\n        identifier === 'mx' &&\n        Array.isArray((node as any).fields) &&\n        (node as any).fields.some(isDeniedField)\n      ) {\n        return true;\n      }\n    }\n\n    for (const value of Object.values(node as any)) {\n      if (Array.isArray(value)) {\n        for (const item of value) {\n          if (item && typeof item === 'object' && 'type' in item) {\n            stack.push(item as BaseMlldNode);\n          }\n        }\n      } else if (value && typeof value === 'object' && 'type' in value) {\n        stack.push(value as BaseMlldNode);\n      }\n    }\n  }\n\n  return false;\n}\n\n/**\n * Determines if a value is truthy according to mlld rules\n * WHY: mlld has specific truthiness rules that differ from JavaScript. Empty strings,\n * empty arrays, and empty objects are falsy, while non-empty values are truthy.\n * GOTCHA: Unlike JavaScript, empty arrays [] and empty objects {} are falsy in mlld.\n * The string \"false\" is truthy (non-empty string), only the boolean false is falsy.\n * CONTEXT: Used in when conditions to determine if branches should execute, especially\n * important for the simple form: /when @var => /action (executes if @var is truthy).\n */\nfunction isTruthy(value: any): boolean {\n  // Handle Variable types\n  if (value && typeof value === 'object' && 'type' in value && 'name' in value) {\n    const variable = value as Variable;\n    \n    // Type-specific truthiness for Variables\n    if (isTextLike(variable)) {\n      // Check for mlld falsy string values\n      const str = variable.value;\n      if (str === '' || str.toLowerCase() === 'false' || str === '0') {\n        return false;\n      }\n      return true;\n    } else if (isArrayVariable(variable)) {\n      return variable.value.length > 0;\n    } else if (isObjectVariable(variable)) {\n      return Object.keys(variable.value).length > 0;\n    } else if (isCommandResult(variable)) {\n      // Command results are truthy if they have output\n      return variable.value.trim().length > 0;\n    } else if (isPipelineInput(variable)) {\n      assertStructuredValue(variable.value, 'when:isTruthy:pipeline-input');\n      return asText(variable.value).length > 0;\n    }\n    \n    // For other variable types, use their value\n    return isTruthy(variable.value);\n  }\n  \n  if (isStructuredValue(value)) {\n    try {\n      const structuredData = asData(value);\n      return isTruthy(structuredData);\n    } catch {\n      return isTruthy(asText(value));\n    }\n  }\n  \n  // Handle null/undefined\n  if (value === null || value === undefined) {\n    return false;\n  }\n  \n  // Handle booleans\n  if (typeof value === 'boolean') {\n    return value;\n  }\n  \n  // Handle strings\n  if (typeof value === 'string') {\n    // Empty string is false\n    if (value === '') {\n      return false;\n    }\n    \n    // String \"false\" is false (case insensitive)\n    if (value.toLowerCase() === 'false') {\n      return false;\n    }\n    \n    // String \"0\" is false\n    if (value === '0') {\n      return false;\n    }\n    \n    // All other strings are true\n    return true;\n  }\n  \n  // Handle numbers\n  if (typeof value === 'number') {\n    // 0 and NaN are false\n    return value !== 0 && !isNaN(value);\n  }\n  \n  // Handle arrays\n  if (Array.isArray(value)) {\n    // Empty array is false\n    return value.length > 0;\n  }\n  \n  // Handle objects\n  if (typeof value === 'object') {\n    // Empty object is false\n    return Object.keys(value).length > 0;\n  }\n  \n  // Default to true for other types\n  return true;\n}\n\n/**\n * Check if a condition is the 'none' literal\n */\nfunction isNoneCondition(condition: any): boolean {\n  return condition?.type === 'Literal' && condition?.valueType === 'none';\n}\n\n/**\n * Validate that 'none' conditions are placed correctly in a when block\n */\nfunction validateNonePlacement(conditions: any[]): void {\n  let foundNone = false;\n  let foundWildcard = false;\n  \n  for (let i = 0; i < conditions.length; i++) {\n    const condition = conditions[i].condition || conditions[i];\n    \n    if (isNoneCondition(condition)) {\n      foundNone = true;\n    } else if (condition?.type === 'Literal' && condition?.valueType === 'wildcard') {\n      foundWildcard = true;\n      if (foundNone) {\n        // * after none is technically valid but makes none unreachable\n        continue;\n      }\n    } else if (foundNone) {\n      throw new Error(\n        'The \"none\" keyword can only appear as the last condition(s) in a when block'\n      );\n    }\n    \n    if (foundWildcard && isNoneCondition(condition)) {\n      throw new Error(\n        'The \"none\" keyword cannot appear after \"*\" (wildcard) as it would never be reached'\n      );\n    }\n  }\n}\n","import type { Environment } from '../../env/Environment';\n\n/**\n * Represents the state of an evaluation operation\n */\nexport interface EvaluationState {\n  evaluated: boolean;\n  result?: any;\n  error?: Error;\n  depth?: number;\n  maxDepth?: number;\n}\n\n/**\n * Result of a cache lookup operation\n */\nexport interface CacheResult {\n  hit: boolean;\n  result?: any;\n  error?: Error;\n}\n\n/**\n * Manages evaluation state and caching for data value evaluations.\n * \n * This class provides:\n * - Evaluation result caching with object reference keys\n * - Error state preservation (caching both success and failure states)\n * - Cache management and performance monitoring\n */\nexport class EvaluationStateManager {\n  private evaluationCache = new Map<any, EvaluationState>();\n\n  /**\n   * Attempts to retrieve a cached evaluation result\n   * @param value The data value to check cache for\n   * @returns Cache result with hit status and cached data/error\n   */\n  getCachedResult(value: any): CacheResult | null {\n    const cached = this.evaluationCache.get(value);\n    \n    if (!cached) {\n      return null;\n    }\n\n    // Only return cache hit if evaluation completed and no error occurred\n    if (cached.evaluated && !cached.error) {\n      return {\n        hit: true,\n        result: cached.result\n      };\n    }\n\n    // Return cached error if evaluation failed\n    if (cached.evaluated && cached.error) {\n      return {\n        hit: true,\n        error: cached.error\n      };\n    }\n\n    return null;\n  }\n\n  /**\n   * Stores an evaluation result in the cache\n   * @param value The data value to cache results for\n   * @param result The evaluation result (if successful)\n   * @param error The error that occurred (if failed)\n   */\n  setCachedResult(value: any, result?: any, error?: Error): void {\n    const state: EvaluationState = {\n      evaluated: true,\n      result,\n      error\n    };\n    \n    this.evaluationCache.set(value, state);\n  }\n\n  /**\n   * Clears all cached evaluation results\n   */\n  clearCache(): void {\n    this.evaluationCache.clear();\n  }\n\n  /**\n   * Gets cache performance statistics\n   * @returns Object with cache size and other metrics\n   */\n  getCacheStats(): { size: number; entries: number } {\n    return {\n      size: this.evaluationCache.size,\n      entries: this.evaluationCache.size\n    };\n  }\n\n  /**\n   * Removes a specific cache entry\n   * @param value The data value to remove from cache\n   */\n  removeCacheEntry(value: any): boolean {\n    return this.evaluationCache.delete(value);\n  }\n\n  /**\n   * Checks if a value has been cached\n   * @param value The data value to check\n   * @returns True if value is in cache\n   */\n  isCached(value: any): boolean {\n    return this.evaluationCache.has(value);\n  }\n}","import type { Environment } from '../../env/Environment';\nimport type { DataValue } from '@core/types/var';\nimport { isDirectiveValue, isPrimitiveValue } from '@core/types/var';\nimport { evaluate } from '../../core/interpreter';\nimport { EvaluationStateManager } from './EvaluationStateManager';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { InterpolationContext } from '../../core/interpolation-context';\n\nasync function interpolateAndRecord(\n  nodes: any,\n  env: Environment,\n  context: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  const { interpolate } = await import('../../core/interpreter');\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n\n/**\n * Handles evaluation of primitive data values and simple AST nodes.\n * \n * This evaluator processes:\n * - Primitive values (strings, numbers, booleans, null)\n * - Text AST nodes\n * - Embedded directive values with caching\n */\nexport class PrimitiveEvaluator {\n  constructor(private stateManager: EvaluationStateManager) {}\n\n  /**\n   * Checks if this evaluator can handle the given data value\n   */\n  canHandle(value: DataValue): boolean {\n    // Handle primitive values\n    if (isPrimitiveValue(value)) {\n      return true;\n    }\n    \n    // Handle Text nodes\n    if (value && typeof value === 'object' && value.type === 'Text' && 'content' in value) {\n      return true;\n    }\n\n    // Handle Literal nodes (from grammar)\n    if (value && typeof value === 'object' && value.type === 'Literal' && 'value' in value) {\n      return true;\n    }\n\n    if (value && typeof value === 'object' && value.type === 'RegexLiteral') {\n      return true;\n    }\n    \n    // Handle wrapped string values (with content array and wrapperType)\n    if (value && typeof value === 'object' && 'wrapperType' in value && 'content' in value && Array.isArray(value.content)) {\n      return true;\n    }\n\n    // Handle needsInterpolation marker (from DataString with @references)\n    if (value && typeof value === 'object' && 'needsInterpolation' in value && 'parts' in value && Array.isArray((value as any).parts)) {\n      return true;\n    }\n    \n    // Handle command objects (from run directives in objects)\n    if (value && typeof value === 'object' && value.type === 'command' && 'command' in value) {\n      return true;\n    }\n    \n    // Handle embedded directives\n    if (isDirectiveValue(value)) {\n      return true;\n    }\n    \n    return false;\n  }\n\n  /**\n   * Evaluates primitive data values and simple AST nodes\n   */\n  async evaluate(value: DataValue, env: Environment): Promise<any> {\n    // Primitive values pass through unchanged\n    if (isPrimitiveValue(value)) {\n      return value;\n    }\n    \n    // Handle Text nodes\n    if (value && typeof value === 'object' && value.type === 'Text' && 'content' in value) {\n      return value.content;\n    }\n\n    // Handle Literal nodes (from grammar) - extract the value\n    if (value && typeof value === 'object' && value.type === 'Literal' && 'value' in value) {\n      return (value as { value: unknown }).value;\n    }\n\n    // Handle regex literals\n    if (value && typeof value === 'object' && value.type === 'RegexLiteral') {\n      const pattern = (value as any).pattern || '';\n      const flags = (value as any).flags || '';\n      return new RegExp(pattern, flags);\n    }\n    \n    // Handle wrapped string values (quotes, backticks, or brackets)\n    if (value && typeof value === 'object' && 'wrapperType' in value && 'content' in value && Array.isArray(value.content)) {\n      const contentArray: any[] = value.content as any[];\n      const hasOnlyLiteralsOrText = contentArray.every(\n        node =>\n          node &&\n          typeof node === 'object' &&\n          ((node.type === 'Literal' && 'value' in node) || (node.type === 'Text' && 'content' in node))\n      );\n      if (hasOnlyLiteralsOrText) {\n        if (process.env.MLLD_DEBUG_FIX === 'true') {\n          console.error('[PrimitiveEvaluator] literal/text wrapper', {\n            wrapperType: (value as any).wrapperType,\n            items: contentArray.map(n => n?.type)\n          });\n        }\n        return contentArray\n          .map(node => (node.type === 'Literal' ? (node as any).value : (node as any).content))\n          .join('');\n      }\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        console.error('[PrimitiveEvaluator] interpolating wrapper', {\n          wrapperType: (value as any).wrapperType,\n          itemTypes: contentArray.map(n => n?.type)\n        });\n      }\n      return await interpolateAndRecord(value.content, env);\n    }\n\n    // Handle needsInterpolation marker (from DataString with @references in object literals)\n    if (value && typeof value === 'object' && 'needsInterpolation' in value && 'parts' in value && Array.isArray((value as any).parts)) {\n      return await interpolateAndRecord((value as any).parts, env);\n    }\n\n    // Handle command objects (from run directives in objects)\n    if (value && typeof value === 'object' && value.type === 'command' && 'command' in value) {\n      return await this.evaluateCommandObject(value, env);\n    }\n    \n    // Handle embedded directives\n    if (isDirectiveValue(value)) {\n      return await this.evaluateDirective(value, env);\n    }\n    \n    throw new Error(`PrimitiveEvaluator cannot handle value type: ${typeof value}`);\n  }\n\n  /**\n   * Evaluates a command object (from run directives in objects)\n   */\n  private async evaluateCommandObject(value: any, env: Environment): Promise<any> {\n    let commandStr: string;\n    if (typeof value.command === 'string') {\n      commandStr = value.command;\n    } else if (Array.isArray(value.command)) {\n      // Interpolate the command array\n      commandStr = await interpolateAndRecord(value.command, env, InterpolationContext.ShellCommand);\n    } else {\n      throw new Error('Invalid command format in command object evaluation');\n    }\n    const result = await env.executeCommand(commandStr);\n    return result;\n  }\n\n  /**\n   * Evaluates an embedded directive with caching\n   */\n  private async evaluateDirective(value: any, env: Environment): Promise<any> {\n    // Check if we've already evaluated this directive\n    const cached = this.stateManager.getCachedResult(value);\n    if (cached?.hit && !cached.error) {\n      return cached.result;\n    }\n    \n    // If we have a cached error, throw it\n    if (cached?.hit && cached.error) {\n      throw cached.error;\n    }\n    \n    try {\n      // Create a child environment to capture output without affecting the parent\n      const childEnv = env.createChild();\n      \n      // Evaluate the directive in the child environment\n      const result = await evaluate([value], childEnv);\n      \n      // For run and add directives in data context, trim trailing newlines\n      let finalValue = result.value;\n      if ((value.kind === 'run' || value.kind === 'add') && typeof finalValue === 'string') {\n        finalValue = finalValue.replace(/\\n+$/, '');\n      }\n      \n      // Cache the result\n      this.stateManager.setCachedResult(value, finalValue);\n      \n      return finalValue;\n    } catch (error) {\n      // Cache the error\n      this.stateManager.setCachedResult(value, undefined, error as Error);\n      throw error;\n    }\n  }\n}\n","import * as fs from 'fs';\nimport type { Environment } from '../../env/Environment';\nimport type { DataValue, DataObjectValue, DataArrayValue } from '@core/types/var';\nimport { interpolate } from '../../core/interpreter';\nimport { asData, isStructuredValue } from '@interpreter/utils/structured-value';\nimport { extractVariableValue } from '@interpreter/utils/variable-resolution';\nimport { accessFields } from '@interpreter/utils/field-access';\nimport { FieldAccessError } from '@core/errors';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { InterpolationContext } from '../../core/interpolation-context';\n\nasync function interpolateAndRecord(\n  nodes: any,\n  env: Environment,\n  context: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n\n/**\n * Handles evaluation of collection data values (objects and arrays).\n * \n * This evaluator processes:\n * - Object values with recursive property evaluation\n * - Array values with recursive element evaluation  \n * - Template content arrays requiring interpolation\n * - Error isolation for individual properties/elements\n */\nexport class CollectionEvaluator {\n  constructor(\n    private evaluateDataValue: (\n      value: DataValue,\n      env: Environment,\n      options?: { suppressErrors?: boolean }\n    ) => Promise<any>\n  ) {}\n\n  /**\n   * Checks if this evaluator can handle the given data value\n   */\n  canHandle(value: DataValue): boolean {\n    if (isStructuredValue(value)) {\n      return true;\n    }\n\n    // Handle objects\n    if (value?.type === 'object') {\n      return true;\n    }\n    \n    // Handle arrays\n    if (value?.type === 'array') {\n      return true;\n    }\n    \n    // Handle regular arrays\n    if (Array.isArray(value)) {\n      // Check if the array contains a single foreach command object\n      if (value.length === 1 && value[0] && typeof value[0] === 'object' && value[0].type === 'foreach-command') {\n        return true;\n      }\n      \n      // Handle array template content\n      const isTemplateContent = value.every(item => \n        item?.type === 'Text' || item?.type === 'VariableReference'\n      );\n      \n      // Also handle already processed arrays (foreach-section results)\n      return isTemplateContent || value.every(item => typeof item === 'string');\n    }\n    \n    // Handle plain objects (from parsed data) without type field\n    if (typeof value === 'object' && value !== null && !value.type && !Array.isArray(value)) {\n      return true;\n    }\n    \n    return false;\n  }\n\n  /**\n   * Evaluates collection data values with recursive evaluation\n   */\n  async evaluate(value: DataValue, env: Environment): Promise<any> {\n    if (isStructuredValue(value)) {\n      return (value as any).data;\n    }\n\n    // Handle objects - recursively evaluate all properties\n    if (value?.type === 'object') {\n      if (!Array.isArray((value as any).entries) && !(value as any).properties) {\n        return value;\n      }\n      return await this.evaluateObject(value as DataObjectValue, env);\n    }\n    \n    // Handle arrays - evaluate all elements\n    if (value?.type === 'array') {\n      const items = (value as any).items ?? (value as any).elements;\n      if (!Array.isArray(items)) {\n        return value;\n      }\n      return await this.evaluateArray(value as DataArrayValue, env);\n    }\n    \n    // Handle array template content\n    if (Array.isArray(value)) {\n      // Check if the array contains a single foreach command object\n      if (value.length === 1 && value[0] && typeof value[0] === 'object' && value[0].type === 'foreach-command') {\n        // Delegate to the main evaluator for foreach handling\n        return await this.evaluateDataValue(value[0], env);\n      }\n      \n      const isTemplateContent = value.every(item => \n        item?.type === 'Text' || item?.type === 'VariableReference'\n      );\n      \n      if (isTemplateContent) {\n        // This is template content that needs interpolation\n        return await interpolateAndRecord(value, env);\n      }\n      \n      // Otherwise it's a regular array that's already been processed\n      // This can happen when foreach-section returns an array of strings\n      return value;\n    }\n    \n    // Handle plain objects (from parsed data) without type field\n    if (typeof value === 'object' && value !== null && !value.type && !Array.isArray(value)) {\n      return await this.evaluatePlainObject(value, env);\n    }\n    \n    throw new Error(`CollectionEvaluator cannot handle value type: ${typeof value}`);\n  }\n\n  /**\n   * Evaluates an object with recursive property evaluation and error isolation\n   * Supports both pair entries and spread entries for object composition\n   */\n  private async evaluateObject(value: DataObjectValue, env: Environment): Promise<Record<string, any>> {\n    const evaluatedObj: Record<string, any> = {};\n\n    // Process each entry in order (pairs and spreads)\n    if (Array.isArray((value as any).entries)) {\n      for (const entry of (value as any).entries) {\n        if (entry.type === 'pair') {\n          // Regular key-value pair\n          try {\n            let evaluated = await this.evaluateDataValue(entry.value, env, { suppressErrors: true });\n            if (isStructuredValue(evaluated)) {\n              evaluated = unwrapStructuredPrimitive(evaluated);\n            }\n            evaluatedObj[entry.key] = evaluated;\n          } catch (error) {\n            // Store error information but continue evaluating other properties\n            evaluatedObj[entry.key] = this.createPropertyError(entry.key, error);\n          }\n        } else if (entry.type === 'conditionalPair') {\n          try {\n            let evaluated = await this.evaluateDataValue(entry.value, env, { suppressErrors: true });\n            if (isStructuredValue(evaluated)) {\n              evaluated = unwrapStructuredPrimitive(evaluated);\n            }\n            const { isTruthy } = await import('../expression');\n            if (isTruthy(evaluated)) {\n              evaluatedObj[entry.key] = evaluated;\n            }\n          } catch (error) {\n            if (this.isConditionalOmissionError(error)) {\n              continue;\n            }\n            evaluatedObj[entry.key] = this.createPropertyError(entry.key, error);\n          }\n        } else if (entry.type === 'spread') {\n          // Spread entry: evaluate the variable and merge its properties\n          try {\n            const [varRef] = entry.value;\n            const varName = varRef?.identifier;\n            // Get the variable value from environment\n            const spreadVariable = varName ? env.getVariable(varName) : undefined;\n            if (!spreadVariable) {\n              throw new Error(`Cannot spread undefined variable: ${varName}`);\n            }\n\n            // Extract the actual value (handles Variable wrapper)\n            let spreadValue = await extractVariableValue(spreadVariable, env);\n\n            // Apply any field access on the spread reference\n            if (varRef?.fields && varRef.fields.length > 0) {\n              const fieldResult = await accessFields(spreadValue, varRef.fields, {\n                env,\n                preserveContext: false\n              });\n              spreadValue = (fieldResult as any).value ?? fieldResult;\n            }\n\n            if (isStructuredValue(spreadValue)) {\n              spreadValue = asData(spreadValue);\n            }\n\n            // Validate it's an object\n            if (typeof spreadValue !== 'object' || spreadValue === null || Array.isArray(spreadValue)) {\n              throw new Error(\n                `Cannot spread non-object value from ${varName} (got ${Array.isArray(spreadValue) ? 'array' : typeof spreadValue})`\n              );\n            }\n\n            // Merge spread properties (later entries override earlier ones)\n            Object.assign(evaluatedObj, spreadValue);\n          } catch (error) {\n            // For spread errors, we can't assign to a specific key\n            // Re-throw since this affects the whole object\n            throw error;\n          }\n        }\n      }\n      return evaluatedObj;\n    }\n\n    if ((value as any).properties && typeof (value as any).properties === 'object') {\n      for (const [key, propValue] of Object.entries((value as any).properties)) {\n        try {\n          let evaluated = await this.evaluateDataValue(propValue, env, { suppressErrors: true });\n          if (isStructuredValue(evaluated)) {\n            evaluated = unwrapStructuredPrimitive(evaluated);\n          }\n          evaluatedObj[key] = evaluated;\n        } catch (error) {\n          evaluatedObj[key] = this.createPropertyError(key, error);\n        }\n      }\n      return evaluatedObj;\n    }\n\n    return evaluatedObj;\n  }\n\n  /**\n   * Evaluates an array with recursive element evaluation and error isolation\n   */\n  private async evaluateArray(value: DataArrayValue, env: Environment): Promise<any[]> {\n    const evaluatedElements: any[] = [];\n\n    const items = (value as any).items ?? (value as any).elements ?? [];\n    for (let i = 0; i < items.length; i++) {\n      try {\n        const item = items[i] as any;\n\n        if (item?.type === 'ConditionalArrayElement') {\n          const { evaluateConditionalInclusion } = await import('../conditional-inclusion');\n          const { shouldInclude, value } = await evaluateConditionalInclusion(item.condition, env, {\n            valueNode: item.value\n          });\n\n          if (shouldInclude) {\n            let evaluatedValue = value;\n            if (isStructuredValue(evaluatedValue)) {\n              evaluatedValue = unwrapStructuredPrimitive(evaluatedValue);\n            }\n            evaluatedElements.push(evaluatedValue);\n          }\n          continue;\n        }\n\n        // Fast-path literal/text wrappers so nested arrays keep their string content\n        if (item && typeof item === 'object' && 'content' in item && Array.isArray(item.content)) {\n          const hasOnlyLiteralsOrText = (item.content as any[]).every(\n            node =>\n              node &&\n              typeof node === 'object' &&\n              ((node.type === 'Literal' && 'value' in node) || (node.type === 'Text' && 'content' in node))\n          );\n          if (hasOnlyLiteralsOrText) {\n            if (process.env.MLLD_DEBUG_FIX === 'true') {\n              console.error('[CollectionEvaluator] literal/text wrapper', {\n                index: i,\n                wrapperType: (item as any).wrapperType,\n                itemTypes: (item.content as any[]).map(n => n?.type)\n              });\n              try {\n                fs.appendFileSync(\n                  '/tmp/mlld-debug.log',\n                  JSON.stringify({\n                    source: 'CollectionEvaluator',\n                    index: i,\n                    wrapperType: (item as any).wrapperType,\n                    itemTypes: (item.content as any[]).map((n: any) => n?.type)\n                  }) + '\\n'\n                );\n              } catch {}\n            }\n            evaluatedElements.push(\n              (item.content as any[]).map(node => (node.type === 'Literal' ? node.value : node.content)).join('')\n            );\n            continue;\n          }\n        }\n\n        let evaluatedItem = await this.evaluateDataValue(items[i], env, { suppressErrors: true });\n        if (isStructuredValue(evaluatedItem)) {\n          evaluatedItem = unwrapStructuredPrimitive(evaluatedItem);\n        }\n        evaluatedElements.push(evaluatedItem);\n      } catch (error) {\n        // Store error information but continue evaluating other elements\n        evaluatedElements.push(this.createElementError(i, error));\n      }\n    }\n    \n    return evaluatedElements;\n  }\n\n  /**\n   * Creates error object for a failed property evaluation\n   */\n  private createPropertyError(key: string, error: unknown): object {\n    return {\n      __error: true,\n      __message: error instanceof Error ? error.message : String(error),\n      __property: key\n    };\n  }\n\n  /**\n   * Creates error object for a failed element evaluation\n   */\n  private createElementError(index: number, error: unknown): object {\n    return {\n      __error: true,\n      __message: error instanceof Error ? error.message : String(error),\n      __index: index\n    };\n  }\n\n  /**\n   * Evaluates a plain object (without type field) recursively\n   */\n  private async evaluatePlainObject(value: Record<string, any>, env: Environment): Promise<Record<string, any>> {\n    const evaluatedObject: Record<string, any> = {};\n    \n    for (const [key, propValue] of Object.entries(value)) {\n      // Skip internal properties that shouldn't be in the result\n      if (key === 'wrapperType' || key === 'nodeId' || key === 'location') {\n        continue;\n      }\n      \n      try {\n        let evaluated = await this.evaluateDataValue(propValue, env, { suppressErrors: true });\n        if (isStructuredValue(evaluated)) {\n          evaluated = unwrapStructuredPrimitive(evaluated);\n        }\n        evaluatedObject[key] = evaluated;\n      } catch (error) {\n        // Include the error in the result but don't stop evaluation\n        evaluatedObject[key] = this.createPropertyError(key, error);\n      }\n    }\n    \n    return evaluatedObject;\n  }\n\n  private isConditionalOmissionError(error: unknown): boolean {\n    if (error instanceof FieldAccessError) {\n      return true;\n    }\n    if (error instanceof Error) {\n      return error.message.includes('Variable not found');\n    }\n    return false;\n  }\n}\n\nfunction unwrapStructuredPrimitive(value: any): any {\n  if (!isStructuredValue(value)) {\n    return value;\n  }\n\n  const data = value.data;\n  if (data === null || data === undefined) {\n    return data;\n  }\n\n  if (typeof data === 'object') {\n    return value;\n  }\n\n  return data;\n}\n","import type { Environment } from '../../env/Environment';\nimport type { DataValue } from '@core/types/var';\nimport { isVariableReferenceValue, isTemplateValue } from '@core/types/var';\nimport { \n  isExecutable,\n  isArray,\n  isObject,\n  isTextLike,\n  isPath,\n  isImported,\n  isStructuredValueVariable,\n  Variable\n} from '@core/types/variable';\nimport { interpolate } from '../../core/interpreter';\nimport { accessField, accessFields } from '../../utils/field-access';\nimport { logger } from '@core/utils/logger';\nimport { inheritExpressionProvenance } from '@core/types/provenance/ExpressionProvenance';\nimport { varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { InterpolationContext } from '../../core/interpolation-context';\n\nasync function interpolateAndRecord(\n  nodes: any,\n  env: Environment,\n  context: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n\n/**\n * Handles evaluation of variable references and related operations.\n * \n * This evaluator processes:\n * - Raw VariableReference nodes (not wrapped in array)\n * - VariableReferenceWithTail (with pipelines and modifiers)\n * - Variable references with field access\n * - Template interpolation\n * - ExecInvocation nodes with pipeline support\n */\nexport class VariableReferenceEvaluator {\n  constructor(private evaluateDataValue: (value: DataValue, env: Environment) => Promise<any>) {}\n\n  /**\n   * Checks if this evaluator can handle the given data value\n   */\n  canHandle(value: DataValue): boolean {\n    // Handle raw VariableReference nodes\n    if (value && typeof value === 'object' && value.type === 'VariableReference') {\n      return true;\n    }\n    \n    // Handle variable references with tail modifiers\n    if (value && typeof value === 'object' && value.type === 'VariableReferenceWithTail') {\n      return true;\n    }\n    \n    // Handle standard variable references with field access\n    if (isVariableReferenceValue(value)) {\n      return true;\n    }\n    \n    // Handle template interpolation\n    if (isTemplateValue(value)) {\n      return true;\n    }\n    \n    // Handle ExecInvocation nodes\n    if (value && typeof value === 'object' && value.type === 'ExecInvocation') {\n      return true;\n    }\n    \n    // Handle runExec nodes (run @command() in object context)\n    if (value && typeof value === 'object' && value.type === 'runExec' && 'invocation' in value) {\n      return true;\n    }\n    \n    // Handle path nodes (from [/path/to/file])\n    if (value && typeof value === 'object' && value.type === 'path') {\n      return true;\n    }\n    \n    // Handle content arrays (like template content)\n    if (value && typeof value === 'object' && value.content && Array.isArray(value.content)) {\n      return true;\n    }\n    \n    // Handle executable code objects (from imported executable variables)\n    if (value && typeof value === 'object' && \n        (value.type === 'code' || value.type === 'command') && \n        ('template' in value || 'codeTemplate' in value || 'commandTemplate' in value)) {\n      return true;\n    }\n    \n    return false;\n  }\n\n  /**\n   * Evaluates variable references and related operations\n   */\n  async evaluate(value: DataValue, env: Environment): Promise<any> {\n    // Handle raw VariableReference nodes (not wrapped in array)\n    if (value && typeof value === 'object' && value.type === 'VariableReference') {\n      return await this.evaluateRawVariableReference(value, env);\n    }\n    \n    // Handle variable references with tail modifiers (pipelines, etc.)\n    if (value && typeof value === 'object' && value.type === 'VariableReferenceWithTail') {\n      return await this.evaluateVariableReferenceWithTail(value, env);\n    }\n    \n    // Handle variable references (with potential field access)\n    if (isVariableReferenceValue(value)) {\n      return await this.evaluateVariableReference(value, env);\n    }\n    \n    // Handle template interpolation\n    if (isTemplateValue(value)) {\n      return await interpolateAndRecord(value, env);\n    }\n    \n    // Handle ExecInvocation nodes\n    if (value && typeof value === 'object' && value.type === 'ExecInvocation') {\n      return await this.evaluateExecInvocation(value, env);\n    }\n    \n    // Handle runExec nodes (run @command() in object context)\n    if (value && typeof value === 'object' && value.type === 'runExec' && 'invocation' in value) {\n      return await this.evaluateRunExec(value, env);\n    }\n    \n    // Handle path nodes (from [/path/to/file])\n    if (value && typeof value === 'object' && value.type === 'path') {\n      return await this.evaluatePathNode(value, env);\n    }\n    \n    // Handle content arrays (like template content)\n    if (value && typeof value === 'object' && value.content && Array.isArray(value.content)) {\n      return await interpolateAndRecord(value.content, env);\n    }\n    \n    // Handle executable code objects (from imported executable variables)\n    if (value && typeof value === 'object' && \n        (value.type === 'code' || value.type === 'command') && \n        ('template' in value || 'codeTemplate' in value || 'commandTemplate' in value)) {\n      // This is an executable variable definition - return it as-is\n      // It will be handled by the execution system when invoked\n      return value;\n    }\n    \n    throw new Error(`VariableReferenceEvaluator cannot handle value type: ${typeof value}`);\n  }\n\n  /**\n   * Evaluates a raw VariableReference node\n   */\n  private async evaluateRawVariableReference(value: any, env: Environment): Promise<any> {\n    const variable = env.getVariable(value.identifier);\n    if (!variable) {\n      throw new Error(`Variable not found: ${value.identifier}`);\n    }\n    \n    // For executable variables, return the variable itself (for lazy execution)\n    if (isExecutable(variable)) {\n      return variable;\n    }\n    \n    const hasFieldAccess = Array.isArray(value.fields) && value.fields.length > 0;\n    let result: any;\n    if (hasFieldAccess) {\n      const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n      result = await resolveVariable(variable, env, ResolutionContext.FieldAccess);\n    } else {\n      // Extract the actual value\n      result = await this.extractVariableValue(variable, env);\n    }\n    this.attachProvenance(result, variable as Variable);\n    \n    // Apply field access if present\n    if (hasFieldAccess) {\n      // Apply each field access in sequence\n      for (const field of value.fields) {\n        // Handle variableIndex type - need to resolve the variable first\n        if (field.type === 'variableIndex') {\n          const { evaluateDataValue } = await import('../data-value-evaluator');\n          const indexNode =\n            typeof field.value === 'object'\n              ? (field.value as any)\n              : {\n                  type: 'VariableReference',\n                  valueType: 'varIdentifier',\n                  identifier: String(field.value)\n                };\n          const indexValue = await evaluateDataValue(indexNode as any, env);\n          // Create a new field with the resolved value\n          const resolvedField = { type: 'bracketAccess' as const, value: indexValue };\n          const fieldResult = await accessField(result, resolvedField, { \n            preserveContext: true,\n            env,\n            sourceLocation: (value as any)?.location \n          });\n          result = (fieldResult as any).value;\n        } else {\n          const fieldResult = await accessField(result, field, { \n            preserveContext: true,\n            env,\n            sourceLocation: (value as any)?.location \n          });\n          result = (fieldResult as any).value;\n\n          // Resolve nested variable references returned from AST objects\n          if (\n            result &&\n            typeof result === 'object' &&\n            result.type === 'VariableReference' &&\n            'identifier' in result\n          ) {\n            const nestedVar = env.getVariable((result as any).identifier);\n            if (!nestedVar) {\n              throw new Error(`Variable not found: ${(result as any).identifier}`);\n            }\n            const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n            result = await resolveVariable(nestedVar, env, ResolutionContext.FieldAccess);\n          }\n        }\n      }\n    }\n    \n    return result;\n  }\n\n  /**\n   * Evaluates a VariableReferenceWithTail (with pipelines and modifiers)\n   */\n  private async evaluateVariableReferenceWithTail(value: any, env: Environment): Promise<any> {\n    // First resolve the variable value\n    const varRef = value.variable;\n    const variable = env.getVariable(varRef.identifier);\n    if (!variable) {\n      throw new Error(`Variable not found: ${varRef.identifier}`);\n    }\n    \n    // Get the base value using new type guards\n    let result: any;\n    if (isTextLike(variable)) {\n      // All text-producing types\n      result = variable.value;\n    } else if (isPath(variable)) {\n      result = variable.value.resolvedPath;\n    } else if (isExecutable(variable)) {\n      // If we have a pipeline, we need to execute the variable to get its value\n      if (value.withClause && value.withClause.pipeline) {\n        // Execute the function to get its result\n        const { evaluateExecInvocation } = await import('../exec-invocation');\n        result = await evaluateExecInvocation({\n          type: 'ExecInvocation',\n          identifier: varRef.identifier,\n          args: [],\n          withClause: null\n        } as any, env);\n      } else {\n        // For non-pipeline cases, return the variable for lazy evaluation\n        result = variable;\n      }\n    } else if (isImported(variable)) {\n      // Preserve imported Variables to maintain type information\n      result = variable;\n    } else if (isObject(variable) || isArray(variable)) {\n      // Handle structured data - preserve Variables in data structures\n      const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n      result = await resolveVariable(variable, env, ResolutionContext.DataStructure);\n    } else {\n      // Fallback for any other types - preserve Variables\n      const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n      result = await resolveVariable(variable, env, ResolutionContext.DataStructure);\n    }\n    \n    // Apply field access if present\n    this.attachProvenance(result, variable as Variable);\n\n    if (varRef.fields && varRef.fields.length > 0) {\n      // DEBUG: Log what we're about to access  \n      if (process.env.MLLD_DEBUG === 'true') {\n        console.log('🔍 BEFORE FIELD ACCESS (VariableReferenceWithTail):', {\n          variableIdentifier: varRef.identifier,\n          fields: varRef.fields,\n          resultType: typeof result,\n          resultKeys: typeof result === 'object' && result !== null ? Object.keys(result) : 'N/A',\n          resultValue: result\n        });\n      }\n      \n      const { accessFields } = await import('../../utils/field-access');\n      const fieldResult = await accessFields(result, varRef.fields, { \n        preserveContext: true,\n        env \n      });\n      result = fieldResult.value;\n    }\n    \n    // Apply pipeline if present\n    if (value.withClause && value.withClause.pipeline) {\n      // Use unified pipeline processor\n      const { processPipeline } = await import('../../eval/pipeline/unified-processor');\n      result = await processPipeline({\n        value: result,\n        env,\n        node: value,\n        identifier: varRef.identifier,\n        descriptorHint: variable.mx ? varMxToSecurityDescriptor(variable.mx) : undefined\n      });\n    }\n    \n    // Debug logging\n    if (process.env.MLLD_DEBUG === 'true') {\n      logger.debug('VariableReferenceWithTail final result:', {\n        variableIdentifier: varRef.identifier,\n        resultValue: result,\n        resultType: typeof result,\n        resultIsNull: result === null,\n        resultIsUndefined: result === undefined\n      });\n    }\n    \n    return result;\n  }\n\n  /**\n   * Evaluates a standard variable reference with potential field access\n   */\n  private async evaluateVariableReference(value: any, env: Environment): Promise<any> {\n    const variable = env.getVariable(value.identifier);\n    if (!variable) {\n      throw new Error(`Variable not found: ${value.identifier}`);\n    }\n    \n    // For executable variables, return the variable itself (for lazy execution)\n    // This preserves the executable for later execution rather than executing it now\n    if (isExecutable(variable)) {\n      return variable;\n    }\n    \n    const hasFieldAccess = Array.isArray(value.fields) && value.fields.length > 0;\n    let result: any;\n    if (hasFieldAccess) {\n      const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n      result = await resolveVariable(variable, env, ResolutionContext.FieldAccess);\n    } else {\n      // Extract value using new type guards\n      result = await this.extractVariableValue(variable, env);\n    }\n    this.attachProvenance(result, variable);\n    \n    // DEBUG: Log what we extracted\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log('🔍 EXTRACTED VARIABLE VALUE:', {\n        variableIdentifier: value.identifier,\n        variableType: variable.type,\n        resultType: typeof result,\n        resultKeys: typeof result === 'object' && result !== null ? Object.keys(result) : 'N/A',\n        resultValue: result\n      });\n    }\n    \n    // Apply field access if present\n    if (hasFieldAccess) {\n      // Apply each field access in sequence\n      for (const field of value.fields) {\n        // Handle variableIndex type - need to resolve the variable first\n        if (field.type === 'variableIndex') {\n          const indexVar = env.getVariable(field.value);\n          if (!indexVar) {\n            throw new Error(`Variable not found for index: ${field.value}`);\n          }\n          // Extract index value - WHY: Array/object indices must be raw values\n          const { extractVariableValue: extract } = await import('@interpreter/utils/variable-resolution');\n          const indexValue = await extract(indexVar, env);\n          // Create a new field with the resolved value\n          const resolvedField = { type: 'bracketAccess' as const, value: indexValue };\n          const fieldResult = await accessField(result, resolvedField, { \n            preserveContext: true,\n            env,\n            sourceLocation: (value as any)?.location \n          });\n          result = (fieldResult as any).value;\n        } else {\n          const fieldResult = await accessField(result, field, { \n            preserveContext: true,\n            env,\n            sourceLocation: (value as any)?.location \n          });\n          result = (fieldResult as any).value;\n        }\n      }\n    }\n    \n    return result;\n  }\n\n  /**\n   * Evaluates an ExecInvocation node with pipeline support\n   */\n  private async evaluateExecInvocation(value: any, env: Environment): Promise<any> {\n    const { evaluateExecInvocation } = await import('../exec-invocation');\n    \n    // If the ExecInvocation has a pipeline, we need to handle it here\n    // to ensure proper data type handling\n    if (value.withClause && value.withClause.pipeline) {\n      // Create a copy without the withClause to avoid double execution\n      const nodeWithoutPipeline = {\n        ...value,\n        withClause: null\n      };\n      \n      const result = await evaluateExecInvocation(nodeWithoutPipeline as any, env);\n      \n      // Use unified pipeline processor\n      const { processPipeline } = await import('../../eval/pipeline/unified-processor');\n      const pipelineResult = await processPipeline({\n        value: result.value,\n        env,\n        node: value,\n        identifier: value.identifier\n      });\n      \n      // Debug logging\n      if (process.env.MLLD_DEBUG === 'true') {\n        logger.debug('ExecInvocation pipeline result:', {\n          pipelineResult,\n          pipelineResultType: typeof pipelineResult,\n          isPipelineInput: !!(pipelineResult && typeof pipelineResult === 'object' && 'text' in pipelineResult)\n        });\n      }\n      \n      // Try to parse the pipeline result back to maintain type consistency\n      try {\n        const parsed = JSON.parse(pipelineResult);\n        return parsed;\n      } catch {\n        // If JSON parsing fails, return the string as-is\n        return pipelineResult;\n      }\n    }\n    \n    // No pipeline, execute normally\n    const result = await evaluateExecInvocation(value as any, env);\n    \n    // If the result is a JSON string, try to parse it back into an object/array\n    if (typeof result.value === 'string') {\n      try {\n        const parsed = JSON.parse(result.value);\n        return parsed;\n      } catch {\n        // If JSON parsing fails, return the string as-is\n        return result.value;\n      }\n    }\n    \n    return result.value;\n  }\n\n  /**\n   * Extracts the actual value from a variable using type guards\n   * Note: This is used in contexts where we MUST extract the raw value\n   */\n  private async extractVariableValue(variable: any, env: Environment): Promise<any> {\n    let result: any;\n    if (isTextLike(variable)) {\n      result = variable.value;\n    } else if (isPath(variable)) {\n      result = variable.value.resolvedPath;\n    } else if (isImported(variable)) {\n      result = variable.value;\n    } else if (isObject(variable) || isArray(variable) || isStructuredValueVariable(variable)) {\n      // Extract Variable value - WHY: Direct variable references in templates need raw values\n      const { extractVariableValue } = await import('@interpreter/utils/variable-resolution');\n      result = await extractVariableValue(variable, env);\n    } else {\n      // Extract Variable value - WHY: Direct variable references in templates need raw values\n      const { extractVariableValue } = await import('@interpreter/utils/variable-resolution');\n      result = await extractVariableValue(variable, env);\n    }\n    inheritExpressionProvenance(result, variable);\n    return result;\n  }\n\n  /**\n   * Evaluates a runExec node (run @command() in object context)\n   */\n  private async evaluateRunExec(value: any, env: Environment): Promise<any> {\n    const { evaluateExecInvocation } = await import('../exec-invocation');\n    const result = await evaluateExecInvocation(value.invocation as any, env);\n    return result.value;\n  }\n\n  /**\n   * Evaluates a path node (from [/path/to/file])\n   */\n  private async evaluatePathNode(value: any, env: Environment): Promise<any> {\n    // Resolve path segments and read file\n    const resolvedPath = await interpolateAndRecord(value.segments || [], env);\n    const content = await env.fileSystem.readFile(resolvedPath);\n    return content;\n  }\n\n  private attachProvenance(value: unknown, source?: Variable): void {\n    if (!source) {\n      return;\n    }\n    inheritExpressionProvenance(value, source);\n  }\n}\n","import type { Environment } from '../../env/Environment';\nimport type { DataValue } from '@core/types/var';\n\n/**\n * Handles evaluation of foreach command expressions.\n *\n * Delegates directly to the core foreach evaluator to ensure consistent\n * semantics across all execution paths.\n */\nexport class ForeachCommandEvaluator {\n  /**\n   * Checks if this evaluator can handle the given data value.\n   */\n  canHandle(value: DataValue): boolean {\n    return (\n      typeof value === 'object' &&\n      value !== null &&\n      !Array.isArray(value) &&\n      'type' in value &&\n      (value.type === 'foreach' || value.type === 'foreach-command')\n    );\n  }\n\n  /**\n   * Evaluates a foreach command expression.\n   */\n  async evaluate(value: DataValue, env: Environment): Promise<any> {\n    if (!this.canHandle(value)) {\n      throw new Error(`ForeachCommandEvaluator cannot handle value type: ${typeof value}`);\n    }\n    return this.evaluateForeachCommand(value, env);\n  }\n\n  /**\n   * Delegates to the core foreach evaluator.\n   */\n  async evaluateForeachCommand(foreachExpr: any, env: Environment): Promise<any> {\n    const { evaluateForeachCommand } = await import('../foreach');\n    return evaluateForeachCommand(foreachExpr, env);\n  }\n\n  /**\n   * Delegates validation to the core foreach validator.\n   */\n  async validateForeachExpression(\n    foreachExpr: any,\n    env: Environment\n  ): Promise<{ valid: boolean; errors: string[] }> {\n    const { validateForeachExpression } = await import('../foreach');\n    return validateForeachExpression(foreachExpr, env);\n  }\n}\n","import type { Environment } from '../../env/Environment';\nimport type { DataValue } from '@core/types/var';\nimport { createObjectVariable, createArrayVariable } from '@core/types/variable';\nimport { interpolate } from '../../core/interpreter';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { InterpolationContext } from '../../core/interpolation-context';\n\nasync function interpolateAndRecord(\n  nodes: any,\n  env: Environment,\n  context: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n\n/**\n * Handles evaluation of foreach section expressions.\n * \n * This evaluator processes foreach expressions that iterate over arrays\n * and extract sections from files using llmxml integration.\n * \n * Features:\n * - File operations and section extraction\n * - Complex path resolution and variable binding\n * - llmxml integration with fallback extraction\n * - Template application and header replacement\n */\nexport class ForeachSectionEvaluator {\n  constructor(private evaluateDataValue: (value: DataValue, env: Environment) => Promise<any>) {}\n\n  /**\n   * Checks if this evaluator can handle the given data value\n   */\n  canHandle(value: DataValue): boolean {\n    // Handle foreach section expressions\n    if (typeof value === 'object' && value !== null && value.type === 'foreachSection') {\n      return true;\n    }\n    \n    // Handle objects with type 'foreach-section' (from grammar output)\n    if (value && typeof value === 'object' && value.type === 'foreach-section') {\n      return true;\n    }\n    \n    return false;\n  }\n\n  /**\n   * Evaluates a foreach section expression\n   */\n  async evaluate(value: DataValue, env: Environment): Promise<any> {\n    if (this.canHandle(value)) {\n      return await this.evaluateForeachSection(value, env);\n    }\n    \n    throw new Error(`ForeachSectionEvaluator cannot handle value type: ${typeof value}`);\n  }\n\n  /**\n   * Evaluates a ForeachSectionExpression - iterating over arrays with section extraction\n   * Usage: foreach <@array.field # section> as ::template::\n   */\n  async evaluateForeachSection(\n    foreachExpr: any,\n    env: Environment\n  ): Promise<any[]> {\n    const { alligator, arrayVariable, pathField, path, section, template } = foreachExpr.value || foreachExpr;\n    \n    // Handle the new alligator-based structure\n    let actualArrayVariable = arrayVariable;\n    let actualPathField = pathField;\n    let actualPath = path;\n    \n    if (alligator && alligator.type === 'load-content') {\n      // Extract from new alligator structure\n      actualPath = alligator.source?.segments;\n      \n      // Look for a variable reference in the path segments\n      if (actualPath) {\n        for (const part of actualPath) {\n          if (part.type === 'VariableReference' && part.fields && part.fields.length > 0) {\n            actualArrayVariable = part.identifier;\n            actualPathField = part.fields[0].value || part.fields[0].field;\n            break;\n          }\n        }\n      }\n    } else if (!actualArrayVariable && path) {\n      // Legacy support - look for a variable reference in the path\n      for (const part of path) {\n        if (part.type === 'VariableReference' && part.fields && part.fields.length > 0) {\n          actualArrayVariable = part.identifier;\n          actualPathField = part.fields[0].value || part.fields[0].field;\n          break;\n        }\n      }\n    }\n    \n    if (!actualArrayVariable) {\n      throw new Error('Cannot determine array variable from foreach section expression');\n    }\n    \n    // 1. Resolve the source array variable\n    const arrayVar = env.getVariable(actualArrayVariable);\n    if (!arrayVar) {\n      throw new Error(`Array variable not found: ${actualArrayVariable}`);\n    }\n    \n    // 2. Evaluate the array to get items\n    const arrayValue = await this.evaluateDataValue(arrayVar.value, env);\n    if (!Array.isArray(arrayValue)) {\n      throw new Error(`Variable '${actualArrayVariable}' must be an array for foreach section extraction, got ${typeof arrayValue}`);\n    }\n    \n    if (arrayValue.length === 0) {\n      return []; // Return empty array for empty input\n    }\n    \n    // 3. Process each item in the array\n    const results: any[] = [];\n    for (let i = 0; i < arrayValue.length; i++) {\n      const item = arrayValue[i];\n      \n      try {\n        // 4. Create child environment with item bound to array variable name\n        const childEnv = env.createChild();\n        const itemVar = Array.isArray(item) ?\n          createArrayVariable(actualArrayVariable, item, {\n            directive: 'var',\n            syntax: 'array',\n            hasInterpolation: false,\n            isMultiLine: false\n          }, {\n            internal: {\n              isParameter: true,\n              isFullyEvaluated: true\n            }\n          }) :\n          createObjectVariable(actualArrayVariable, item, {\n            directive: 'var',\n            syntax: 'object',\n            hasInterpolation: false,\n            isMultiLine: false\n          }, {\n            internal: {\n              isParameter: true,\n              isFullyEvaluated: true\n            }\n          });\n        childEnv.setParameterVariable(actualArrayVariable, itemVar);\n        \n        // 5. Get the path value\n        let pathValue: string;\n        \n        if (actualPath) {\n          // For flexible path expressions, evaluate the entire path\n          pathValue = await interpolateAndRecord(actualPath, childEnv);\n          // Trim any trailing whitespace from path\n          pathValue = pathValue.trim();\n        } else if (actualPathField) {\n          // For simple case, get path from item field\n          if (!item || typeof item !== 'object') {\n            throw new Error(`Array item ${i + 1} must be an object with '${actualPathField}' field, got ${typeof item}`);\n          }\n          \n          pathValue = item[actualPathField];\n          if (typeof pathValue !== 'string') {\n            throw new Error(`Path field '${actualPathField}' in array item ${i + 1} must be a string, got ${typeof pathValue}`);\n          }\n        } else {\n          throw new Error('No path specified for foreach section extraction');\n        }\n        \n        // 6. Resolve section name (can be literal or variable)\n        let sectionName: string;\n        \n        // Get section from alligator or legacy structure\n        let sectionToProcess = section;\n        if (alligator && alligator.type === 'load-content' && alligator.options?.section) {\n          sectionToProcess = alligator.options.section.identifier;\n        }\n        \n        // Handle section as an array of nodes\n        const sectionNodes = Array.isArray(sectionToProcess) ? sectionToProcess : [sectionToProcess];\n        \n        if (sectionNodes.length === 1 && sectionNodes[0].type === 'Text') {\n          sectionName = sectionNodes[0].content;\n        } else if (sectionNodes.length === 1 && sectionNodes[0].type === 'VariableReference') {\n          // Evaluate section variable in child environment (with current item bound)\n          const sectionValue = await interpolateAndRecord(sectionNodes, childEnv);\n          if (typeof sectionValue !== 'string') {\n            throw new Error(`Section variable must resolve to a string, got ${typeof sectionValue}`);\n          }\n          sectionName = sectionValue;\n        } else if (sectionNodes.length > 0) {\n          // Multiple nodes - interpolate them all\n          const sectionValue = await interpolateAndRecord(sectionNodes, childEnv);\n          if (typeof sectionValue !== 'string') {\n            throw new Error(`Section must resolve to a string, got ${typeof sectionValue}`);\n          }\n          sectionName = sectionValue;\n        } else if (typeof sectionToProcess === 'string') {\n          // Direct string section name\n          sectionName = sectionToProcess;\n        } else if (sectionToProcess && typeof sectionToProcess === 'object' && sectionToProcess.content) {\n          // Object with content property\n          sectionName = sectionToProcess.content;\n        } else {\n          throw new Error('Section name is required for foreach section extraction');\n        }\n        \n        // 7. Read file and extract section from file\n        // Resolve the path relative to the current file\n        const resolvedPath = await env.resolvePath(pathValue);\n        const fileContent = await env.readFile(resolvedPath);\n        \n        // Extract the section using llmxml\n        const { llmxmlInstance } = await import('../../utils/llmxml-instance');\n        let sectionContent: string;\n        try {\n          // getSection expects just the title without the # prefix\n          const titleWithoutHash = sectionName.replace(/^#+\\s*/, '');\n          sectionContent = await llmxmlInstance.getSection(fileContent, titleWithoutHash, {\n            includeNested: true\n          });\n          // Trim trailing whitespace\n          sectionContent = sectionContent.trimEnd();\n        } catch (error) {\n          // Fallback to basic extraction if llmxml fails\n          sectionContent = this.extractSectionBasic(fileContent, sectionName);\n        }\n        \n        // 8. Apply template with current item context\n        const templateResult = await interpolateAndRecord(template.values.content, childEnv);\n        \n        // 9. Replace the first line (header) of section content with template result\n        // This mimics the behavior of the 'as' clause in @add directive\n        const lines = sectionContent.split('\\n');\n        if (lines.length > 0 && lines[0].match(/^#+\\s/)) {\n          // Replace the header line with the template result\n          lines[0] = templateResult;\n          const result = lines.join('\\n');\n          results.push(result);\n        } else {\n          // If no header found, prepend the template result\n          const result = templateResult + '\\n' + sectionContent;\n          results.push(result);\n        }\n        \n      } catch (error) {\n        // Include iteration context in error message\n        const itemInfo = typeof item === 'object' && item !== null \n          ? Object.keys(item).slice(0, 3).map(k => `${k}: ${JSON.stringify(item[k])}`).join(', ')\n          : String(item);\n        \n        throw new Error(\n          `Error in foreach section iteration ${i + 1} (${itemInfo}): ${error instanceof Error ? error.message : String(error)}`\n        );\n      }\n    }\n    \n    return results;\n  }\n\n  /**\n   * Extract a section from markdown content.\n   * Basic fallback implementation when llmxml fails.\n   */\n  private extractSectionBasic(content: string, sectionName: string): string {\n    const lines = content.split('\\n');\n    const sectionRegex = new RegExp(`^#+\\\\s+${sectionName}\\\\s*$`, 'i');\n    \n    let inSection = false;\n    let sectionLevel = 0;\n    const sectionLines: string[] = [];\n    \n    for (const line of lines) {\n      // Check if this line starts our section\n      if (!inSection && sectionRegex.test(line)) {\n        inSection = true;\n        sectionLevel = line.match(/^#+/)?.[0].length || 0;\n        continue; // Skip the header itself\n      }\n      \n      // If we're in the section\n      if (inSection) {\n        // Check if we've hit another header at the same or higher level\n        const headerMatch = line.match(/^(#+)\\s+/);\n        if (headerMatch && headerMatch[1].length <= sectionLevel) {\n          // We've left the section\n          break;\n        }\n        \n        sectionLines.push(line);\n      }\n    }\n    \n    return sectionLines.join('\\n').trim();\n  }\n}\n","/**\n * Implementation classes for content loading with metadata support\n *\n * Note: Legacy array types (LoadContentResultArray, RenamedContentArray) have been\n * removed as of Phase 5 cleanup. All values are now wrapped as StructuredValue.\n */\n\nimport { JSDOM } from 'jsdom';\nimport yaml from 'js-yaml';\nimport type {\n  LoadContentResult,\n  LoadContentResultURL,\n  LoadContentResultHTML\n} from '@core/types/load-content';\nimport {\n  buildTokenMetrics,\n  type TokenEstimationOptions,\n  type TokenMetrics\n} from '@core/utils/token-metrics';\n\n/**\n * Internal class implementation of LoadContentResult\n * Uses lazy getters for expensive operations\n */\nexport class LoadContentResultImpl implements LoadContentResult {\n  content: string;\n  filename: string;\n  relative: string;\n  absolute: string;\n  \n  private _extension: string | null;\n  private _metrics?: TokenMetrics;\n  private _fm?: any;\n  private _fmParsed = false;\n  private _json?: any;\n  private _jsonParsed = false;\n  _rawContent?: string; // For frontmatter parsing when content is a section\n  \n  constructor(data: {\n    content: string;\n    filename: string;\n    relative: string;\n    absolute: string;\n    _rawContent?: string; // Optional: full file content for frontmatter when content is just a section\n  }) {\n    this.content = data.content;\n    this.filename = data.filename;\n    this.relative = data.relative;\n    this.absolute = data.absolute;\n    this._rawContent = data._rawContent;\n    \n    // Extract extension for token estimation\n    const match = this.filename.match(/\\.([a-zA-Z0-9]+)$/);\n    this._extension = match ? match[1].toLowerCase() : null;\n  }\n  \n  get path(): string {\n    return this.absolute;\n  }\n  \n  get ext(): string {\n    return this._extension || '';\n  }\n  \n  get fm(): any {\n    if (!this._fmParsed) {\n      this._fmParsed = true;\n      try {\n        // Use _rawContent if available (when content is a section), otherwise use content\n        const contentToParse = this._rawContent || this.content;\n        // Simple frontmatter extraction\n        const fmMatch = contentToParse.match(/^---\\s*\\n([\\s\\S]*?)\\n---\\s*\\n/);\n        if (fmMatch) {\n          // Parse YAML frontmatter\n          this._fm = yaml.load(fmMatch[1]);\n        }\n      } catch (error) {\n        // Silently fail - no frontmatter\n      }\n    }\n    return this._fm;\n  }\n  \n  private ensureMetrics(): TokenMetrics {\n    if (!this._metrics) {\n      const options: TokenEstimationOptions = {\n        extension: this._extension,\n        format: undefined\n      };\n      this._metrics = buildTokenMetrics(this.content, options);\n    }\n    return this._metrics;\n  }\n\n  get tokest(): number {\n    return this.ensureMetrics().tokest;\n  }\n  \n  get tokens(): number {\n    const metrics = this.ensureMetrics();\n    return metrics.tokens ?? metrics.tokest;\n  }\n  \n  get json(): any {\n    if (!this._jsonParsed) {\n      this._jsonParsed = true;\n      try {\n        this._json = JSON.parse(this.content);\n      } catch {\n        // Not valid JSON\n        this._json = undefined;\n      }\n    }\n    return this._json;\n  }\n  \n  // String conversion returns content\n  toString(): string {\n    return this.content;\n  }\n  \n  // StructuredValue-like surface\n  get type(): 'text' {\n    return 'text';\n  }\n  \n  get text(): string {\n    return this.content;\n  }\n  \n  get data(): string {\n    return this.content;\n  }\n  \n  get mx() {\n    const self = this;\n    return {\n      filename: this.filename,\n      relative: this.relative,\n      absolute: this.absolute,\n      get tokest() { return self.tokest; },\n      get tokens() { return self.tokens; },\n      get fm() { return self.fm; },\n      get json() { return self.json; },\n      type: this.type\n    };\n  }\n  \n  valueOf(): string {\n    return this.content;\n  }\n  \n  [Symbol.toPrimitive](): string {\n    return this.content;\n  }\n  \n  // JSON representation includes metadata\n  toJSON(): any {\n    return {\n      content: this.content,\n      filename: this.filename,\n      relative: this.relative,\n      absolute: this.absolute,\n      ext: this.ext,\n      fm: this.fm,\n      tokest: this.tokest\n    };\n  }\n}\n\n/**\n * URL-specific LoadContentResult with additional metadata\n */\nexport class LoadContentResultURLImpl extends LoadContentResultImpl implements LoadContentResultURL {\n  url: string;\n  domain: string;\n  title?: string;\n  description?: string;\n  status?: number;\n  headers?: Record<string, string>;\n  rawContent: string;\n  \n  constructor(data: {\n    content: string;        // The processed/converted content (markdown for HTML)\n    rawContent: string;     // The raw response content\n    url: string;\n    headers: Record<string, string>;\n    status: number;\n  }) {\n    // Extract filename from URL\n    const urlPath = new URL(data.url).pathname;\n    const filename = urlPath.split('/').pop() || 'index.html';\n    \n    super({\n      content: data.content,\n      filename: filename,\n      relative: data.url,  // URLs use full URL as relative\n      absolute: data.url\n    });\n    \n    this.url = data.url;\n    this.domain = new URL(data.url).hostname;\n    this.headers = data.headers;\n    this.status = data.status;\n    this.rawContent = data.rawContent;\n    \n    // Extract metadata from HTML if it's HTML content\n    const contentType = data.headers['content-type'] || data.headers['Content-Type'] || '';\n    if (contentType.includes('text/html')) {\n      this._extractHtmlMetadata();\n    }\n  }\n  \n  // Getters for common content type properties\n  get contentType(): string | undefined {\n    return this.headers?.['content-type'] || this.headers?.['Content-Type'];\n  }\n  \n  get html(): string | undefined {\n    const contentType = this.contentType;\n    return contentType?.includes('text/html') ? this.rawContent : undefined;\n  }\n  \n  get text(): string | undefined {\n    // For HTML, extract plain text; for others, return raw content\n    const contentType = this.contentType;\n    if (contentType?.includes('text/html')) {\n      try {\n        const dom = new JSDOM(this.rawContent);\n        return dom.window.document.body?.textContent?.trim() || '';\n      } catch {\n        return this.rawContent;\n      }\n    }\n    return this.rawContent;\n  }\n  \n  get md(): string | undefined {\n    // Return markdown content (the processed content for HTML)\n    const contentType = this.contentType;\n    return contentType?.includes('text/html') ? this.content : undefined;\n  }\n  \n  get type(): 'text' | 'object' | 'array' | 'html' {\n    const contentType = this.contentType;\n    if (contentType?.includes('application/json')) {\n      const parsed = this.json;\n      if (Array.isArray(parsed)) return 'array';\n      if (parsed && typeof parsed === 'object') return 'object';\n    }\n    if (contentType?.includes('text/html')) {\n      return 'html';\n    }\n    return 'text';\n  }\n  \n  get mx() {\n    const base = super.mx;\n    return {\n      ...base,\n      url: this.url,\n      domain: this.domain,\n      title: this.title,\n      description: this.description,\n      status: this.status,\n      headers: this.headers,\n      html: this.html\n    };\n  }\n  \n  // JSON representation includes URL metadata\n  toJSON(): any {\n    return {\n      ...super.toJSON(),\n      url: this.url,\n      domain: this.domain,\n      title: this.title,\n      description: this.description,\n      status: this.status,\n      headers: this.headers\n    };\n  }\n  \n  private _extractHtmlMetadata(): void {\n    try {\n      const dom = new JSDOM(this.rawContent);\n      const doc = dom.window.document;\n      \n      // Extract title from various sources\n      const titleElement = doc.querySelector('title');\n      if (titleElement) {\n        this.title = titleElement.textContent?.trim() || undefined;\n      }\n      \n      // If no title tag, try og:title or twitter:title\n      if (!this.title) {\n        const ogTitle = doc.querySelector('meta[property=\"og:title\"]');\n        const twitterTitle = doc.querySelector('meta[name=\"twitter:title\"]');\n        this.title = ogTitle?.getAttribute('content')?.trim() ||\n                    twitterTitle?.getAttribute('content')?.trim() ||\n                    undefined;\n      }\n      \n      // Extract description from various sources\n      const descElement = doc.querySelector('meta[name=\"description\"]') ||\n                         doc.querySelector('meta[property=\"og:description\"]') ||\n                         doc.querySelector('meta[property=\"twitter:description\"]') ||\n                         doc.querySelector('meta[name=\"twitter:description\"]');\n      \n      if (descElement) {\n        this.description = descElement.getAttribute('content')?.trim() || undefined;\n      }\n    } catch (error) {\n      console.warn('DOM parsing failed, falling back to regex:', error);\n      this._extractHtmlMetadataFallback();\n    }\n  }\n  \n  private _extractHtmlMetadataFallback(): void {\n    // Fallback regex extraction\n    const titleMatch = this.rawContent.match(/<title[^>]*>([^<]+)<\\/title>/i);\n    if (titleMatch) {\n      this.title = titleMatch[1].trim();\n    }\n    \n    const descMatch = this.rawContent.match(/<meta\\s+(?:name|property)=[\"'](?:description|og:description|twitter:description)[\"']\\s+content=[\"']([^\"']+)[\"']/i) ||\n                     this.rawContent.match(/<meta\\s+content=[\"']([^\"']+)[\"']\\s+(?:name|property)=[\"'](?:description|og:description|twitter:description)[\"']/i);\n    if (descMatch) {\n      this.description = descMatch[1].trim();\n    }\n  }\n}\n\n/**\n * HTML-specific LoadContentResult for local HTML files\n */\nexport class LoadContentResultHTMLImpl extends LoadContentResultImpl implements LoadContentResultHTML {\n  title?: string;\n  description?: string;\n  private _rawHtml: string;\n  \n  constructor(data: {\n    content: string;      // Markdown version\n    rawHtml: string;      // Original HTML\n    filename: string;\n    relative: string;\n    absolute: string;\n    title?: string;\n    description?: string;\n  }) {\n    super({\n      content: data.content,\n      filename: data.filename,\n      relative: data.relative,\n      absolute: data.absolute\n    });\n    \n    this._rawHtml = data.rawHtml;\n    this.title = data.title;\n    this.description = data.description;\n  }\n  \n  get html(): string {\n    return this._rawHtml;\n  }\n  \n  get text(): string {\n    try {\n      const dom = new JSDOM(this._rawHtml);\n      return dom.window.document.body?.textContent?.trim() || '';\n    } catch {\n      return this._rawHtml;\n    }\n  }\n  \n  get type(): 'html' {\n    return 'html';\n  }\n  \n  get mx() {\n    const base = super.mx;\n    return {\n      ...base,\n      html: this.html\n    };\n  }\n  \n  // JSON representation includes HTML metadata\n  toJSON(): any {\n    return {\n      ...super.toJSON(),\n      title: this.title,\n      description: this.description,\n      html: this._rawHtml\n    };\n  }\n}\n\n// Factory functions removed in Phase 5 of type refactor\n// Use Variable-based alternatives from variable-migration.ts instead\n","import ts from 'typescript';\nimport * as path from 'path';\n\n// Pattern types from grammar\nexport interface AstPatternDefinition {\n  type: 'definition';\n  name: string;\n  usage?: boolean;\n}\n\nexport interface AstPatternTypeFilter {\n  type: 'type-filter';\n  filter: string;\n  usage?: boolean;\n}\n\nexport interface AstPatternTypeFilterAll {\n  type: 'type-filter-all';\n  usage?: boolean;\n}\n\nexport interface AstPatternTypeFilterVar {\n  type: 'type-filter-var';\n  identifier: string;\n  fields?: any[];\n  usage?: boolean;\n}\n\nexport interface AstPatternNameList {\n  type: 'name-list';\n  filter: string;\n  usage?: boolean;\n}\n\nexport interface AstPatternNameListAll {\n  type: 'name-list-all';\n  usage?: boolean;\n}\n\nexport interface AstPatternNameListVar {\n  type: 'name-list-var';\n  identifier: string;\n  fields?: any[];\n  usage?: boolean;\n}\n\n// Legacy pattern type for backwards compatibility\nexport interface AstPatternLegacy {\n  type: 'definition' | 'usage';\n  name: string;\n}\n\nexport type AstPattern =\n  | AstPatternDefinition\n  | AstPatternTypeFilter\n  | AstPatternTypeFilterAll\n  | AstPatternTypeFilterVar\n  | AstPatternNameList\n  | AstPatternNameListAll\n  | AstPatternNameListVar\n  | AstPatternLegacy;\n\nexport interface AstResult {\n  name: string;\n  code: string;\n  type: string;\n  line: number;\n  file?: string;\n}\n\ninterface Definition {\n  name: string;\n  type: string;\n  start: number;\n  end: number;\n  line: number;\n  code: string;\n  search: string;\n}\n\ntype SequenceEntry = { kind: 'definition'; key: string } | { kind: 'null' };\n\n// Type filter mappings - maps filter keywords to definition types\nconst TYPE_FILTER_MAP: Record<string, string[]> = {\n  fn: ['function', 'method'],\n  var: ['variable', 'constant'],\n  class: ['class'],\n  interface: ['interface'],\n  type: ['type-alias'],\n  enum: ['enum'],\n  struct: ['struct'],\n  trait: ['trait'],\n  module: ['module'],\n};\n\n/**\n * Check if a pattern contains wildcard characters\n */\nfunction isWildcardPattern(name: string): boolean {\n  return name.includes('*') || name.includes('?');\n}\n\n/**\n * Create a matcher function for symbol names\n * Supports glob-style wildcards: * matches any chars, ? matches single char\n */\nfunction createSymbolMatcher(pattern: string): (name: string) => boolean {\n  if (!isWildcardPattern(pattern)) {\n    return (name: string) => name === pattern;\n  }\n  // Convert glob to regex: escape special chars, then convert * and ?\n  const regexPattern = pattern\n    .replace(/[.+^${}()|[\\]\\\\]/g, '\\\\$&') // Escape regex special chars (except * and ?)\n    .replace(/\\*/g, '.*')\n    .replace(/\\?/g, '.');\n  const regex = new RegExp(`^${regexPattern}$`);\n  return (name: string) => regex.test(name);\n}\n\n/**\n * Check if a definition matches a type filter\n */\nfunction matchesTypeFilter(defType: string, filter: string): boolean {\n  const allowedTypes = TYPE_FILTER_MAP[filter];\n  return allowedTypes ? allowedTypes.includes(defType) : false;\n}\n\n/**\n * Check if any pattern in the list is a name-list pattern\n */\nfunction hasNameListPattern(patterns: AstPattern[]): boolean {\n  return patterns.some(p =>\n    p.type === 'name-list' || p.type === 'name-list-all' || p.type === 'name-list-var'\n  );\n}\n\n/**\n * Check if any pattern in the list is a content pattern (definition, type-filter, etc.)\n */\nfunction hasContentPattern(patterns: AstPattern[]): boolean {\n  return patterns.some(p =>\n    p.type === 'definition' || p.type === 'usage' ||\n    p.type === 'type-filter' || p.type === 'type-filter-all' || p.type === 'type-filter-var'\n  );\n}\n\nfunction getLinesAndOffsets(content: string): { lines: string[]; offsets: number[] } {\n  const lines = content.split(/\\r?\\n/);\n  const offsets: number[] = [];\n  let pos = 0;\n  for (const line of lines) {\n    offsets.push(pos);\n    pos += line.length + 1;\n  }\n  return { lines, offsets };\n}\n\nexport function extractAst(content: string, filePath: string, patterns: AstPattern[]): Array<AstResult | null> {\n  const ext = path.extname(filePath).toLowerCase();\n  let definitions: Definition[] = [];\n\n  if (['.py', '.pyi'].includes(ext)) {\n    definitions = extractPythonDefinitions(content);\n  } else if (ext === '.rb') {\n    definitions = extractRubyDefinitions(content);\n  } else if (ext === '.go') {\n    definitions = extractGoDefinitions(content);\n  } else if (ext === '.rs') {\n    definitions = extractRustDefinitions(content);\n  } else if (ext === '.java') {\n    definitions = extractJavaDefinitions(content);\n  } else if (ext === '.sol') {\n    definitions = extractSolidityDefinitions(content);\n  } else if (['.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hh', '.hxx'].includes(ext)) {\n    definitions = extractCppDefinitions(content);\n  } else if (ext === '.cs') {\n    definitions = extractCSharpDefinitions(content);\n  } else {\n    definitions = extractTsDefinitions(content, filePath);\n  }\n\n\n  const definitionMap = new Map<string, Definition>();\n  const sequence: SequenceEntry[] = [];\n\n  function toResult(def: Definition): AstResult {\n    return { name: def.name, code: def.code, type: def.type, line: def.line };\n  }\n\n  function keyOf(def: Definition): string {\n    return `${def.start}:${def.end}:${def.name}`;\n  }\n\n  function contains(container: Definition, child: Definition): boolean {\n    return (\n      container.start <= child.start &&\n      container.end >= child.end &&\n      (container.start < child.start || container.end > child.end)\n    );\n  }\n\n  function pushDefinition(def: Definition): void {\n    const key = keyOf(def);\n    if (definitionMap.has(key)) {\n      return;\n    }\n\n    for (const existing of definitionMap.values()) {\n      if (contains(existing, def)) {\n        return;\n      }\n    }\n\n    for (const [existingKey, existing] of definitionMap) {\n      if (contains(def, existing)) {\n        definitionMap.delete(existingKey);\n        const index = sequence.findIndex(entry => entry.kind === 'definition' && entry.key === existingKey);\n        if (index !== -1) {\n          sequence.splice(index, 1);\n        }\n      }\n    }\n\n    definitionMap.set(key, def);\n    sequence.push({ kind: 'definition', key });\n  }\n\n  for (const pattern of patterns) {\n    // Handle type-filter-all: { * } - all definitions\n    if (pattern.type === 'type-filter-all') {\n      if (pattern.usage) {\n        // Usage pattern with all types - find functions that use any definition\n        // For simplicity, return all non-variable definitions\n        const matches = definitions.filter(def => def.type !== 'variable');\n        if (matches.length === 0) {\n          sequence.push({ kind: 'null' });\n        } else {\n          for (const def of matches) {\n            pushDefinition(def);\n          }\n        }\n      } else {\n        // Return all definitions\n        if (definitions.length === 0) {\n          sequence.push({ kind: 'null' });\n        } else {\n          for (const def of definitions) {\n            pushDefinition(def);\n          }\n        }\n      }\n      continue;\n    }\n\n    // Handle type-filter: { *fn }, { *var }, { *class }, etc.\n    if (pattern.type === 'type-filter') {\n      const matches = definitions.filter(def => matchesTypeFilter(def.type, pattern.filter));\n      if (pattern.usage) {\n        // Usage pattern - find functions that use any of the matched definitions\n        const matchedNames = new Set(matches.map(m => m.name));\n        const usageMatches = definitions.filter(def => {\n          if (def.type === 'variable') return false;\n          return matches.some(m => {\n            const regex = new RegExp(`\\\\b${escapeRegExp(m.name)}\\\\b`);\n            return regex.test(def.search);\n          });\n        });\n        const filteredUsages = usageMatches.filter(def =>\n          !usageMatches.some(other => other !== def && contains(def, other))\n        );\n        if (filteredUsages.length === 0) {\n          sequence.push({ kind: 'null' });\n        } else {\n          for (const def of filteredUsages) {\n            pushDefinition(def);\n          }\n        }\n      } else {\n        if (matches.length === 0) {\n          sequence.push({ kind: 'null' });\n        } else {\n          for (const def of matches) {\n            pushDefinition(def);\n          }\n        }\n      }\n      continue;\n    }\n\n    // Handle definition patterns (may include wildcards in name)\n    if (pattern.type === 'definition') {\n      const patternName = pattern.name;\n\n      if (isWildcardPattern(patternName)) {\n        // Wildcard pattern: handle*, *Validator, *Request*\n        const matcher = createSymbolMatcher(patternName);\n        const matches = definitions.filter(d => matcher(d.name));\n\n        if (pattern.usage) {\n          // Usage pattern with wildcards - find functions that use any matching definition\n          const usageMatches = definitions.filter(def => {\n            if (def.type === 'variable') return false;\n            return matches.some(m => {\n              const regex = new RegExp(`\\\\b${escapeRegExp(m.name)}\\\\b`);\n              return regex.test(def.search);\n            });\n          });\n          const filteredUsages = usageMatches.filter(def =>\n            !usageMatches.some(other => other !== def && contains(def, other))\n          );\n          if (filteredUsages.length === 0) {\n            sequence.push({ kind: 'null' });\n          } else {\n            for (const def of filteredUsages) {\n              pushDefinition(def);\n            }\n          }\n        } else {\n          if (matches.length === 0) {\n            sequence.push({ kind: 'null' });\n          } else {\n            for (const def of matches) {\n              pushDefinition(def);\n            }\n          }\n        }\n      } else if (pattern.usage) {\n        // Exact name with usage flag (parentheses syntax)\n        const regex = new RegExp(`\\\\b${escapeRegExp(patternName)}\\\\b`);\n        const matches = definitions.filter(def => def.type !== 'variable' && regex.test(def.search));\n        const filteredMatches = matches.filter(def =>\n          !matches.some(other => other !== def && contains(def, other))\n        );\n        if (filteredMatches.length === 0) {\n          sequence.push({ kind: 'null' });\n        } else {\n          for (const def of filteredMatches) {\n            pushDefinition(def);\n          }\n        }\n      } else {\n        // Exact match (original behavior)\n        const def = definitions.find(d => d.name === patternName);\n        if (def) {\n          pushDefinition(def);\n        } else {\n          sequence.push({ kind: 'null' });\n        }\n      }\n      continue;\n    }\n\n    // Handle legacy usage pattern type (type === 'usage')\n    if (pattern.type === 'usage') {\n      const legacyPattern = pattern as AstPatternLegacy;\n      const regex = new RegExp(`\\\\b${escapeRegExp(legacyPattern.name)}\\\\b`);\n      const matches = definitions.filter(def => def.type !== 'variable' && regex.test(def.search));\n      const filteredMatches = matches.filter(def =>\n        !matches.some(other => other !== def && contains(def, other))\n      );\n      if (filteredMatches.length === 0) {\n        sequence.push({ kind: 'null' });\n        continue;\n      }\n      for (const def of filteredMatches) {\n        pushDefinition(def);\n      }\n      continue;\n    }\n\n    // Note: name-list patterns are handled separately in extractNames()\n    // type-filter-var and name-list-var need variable resolution before calling this function\n  }\n\n  return sequence.map(entry => {\n    if (entry.kind === 'null') {\n      return null;\n    }\n    const def = definitionMap.get(entry.key);\n    return def ? toResult(def) : null;\n  });\n}\n\n/**\n * Extract definition names from a file (for name-list patterns: ??, fn??, etc.)\n * Returns an array of definition names as strings\n */\nexport function extractNames(content: string, filePath: string, filter?: string): string[] {\n  const ext = path.extname(filePath).toLowerCase();\n  let definitions: Definition[] = [];\n\n  if (['.py', '.pyi'].includes(ext)) {\n    definitions = extractPythonDefinitions(content);\n  } else if (ext === '.rb') {\n    definitions = extractRubyDefinitions(content);\n  } else if (ext === '.go') {\n    definitions = extractGoDefinitions(content);\n  } else if (ext === '.rs') {\n    definitions = extractRustDefinitions(content);\n  } else if (ext === '.java') {\n    definitions = extractJavaDefinitions(content);\n  } else if (ext === '.sol') {\n    definitions = extractSolidityDefinitions(content);\n  } else if (['.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hh', '.hxx'].includes(ext)) {\n    definitions = extractCppDefinitions(content);\n  } else if (ext === '.cs') {\n    definitions = extractCSharpDefinitions(content);\n  } else {\n    definitions = extractTsDefinitions(content, filePath);\n  }\n\n  // Filter by type if specified\n  let filtered: Definition[];\n  if (filter) {\n    filtered = definitions.filter(d => matchesTypeFilter(d.type, filter));\n  } else {\n    // For name-list-all (no filter), exclude nested definitions (methods, constructors)\n    // to only return top-level definitions\n    const nestedTypes = ['method', 'constructor'];\n    filtered = definitions.filter(d => !nestedTypes.includes(d.type));\n  }\n\n  // Extract unique names, sorted alphabetically\n  const names = [...new Set(filtered.map(d => d.name))];\n  names.sort();\n  return names;\n}\n\n/**\n * Check if patterns contain any name-list patterns\n */\nexport { hasNameListPattern, hasContentPattern, matchesTypeFilter, TYPE_FILTER_MAP };\n\nfunction extractTsDefinitions(content: string, filePath: string): Definition[] {\n  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);\n  const defs: Definition[] = [];\n\n  for (const stmt of sourceFile.statements) {\n    if (ts.isFunctionDeclaration(stmt) && stmt.name) {\n      defs.push(makeTsDefinition(stmt.name.text, 'function', stmt, sourceFile, content));\n    } else if (ts.isClassDeclaration(stmt) && stmt.name) {\n      defs.push(makeTsDefinition(stmt.name.text, 'class', stmt, sourceFile, content));\n      for (const member of stmt.members) {\n        if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {\n          defs.push(makeTsDefinition(member.name.text, 'method', member, sourceFile, content));\n        }\n      }\n    } else if (ts.isInterfaceDeclaration(stmt) && stmt.name) {\n      defs.push(makeTsDefinition(stmt.name.text, 'interface', stmt, sourceFile, content));\n    } else if (ts.isEnumDeclaration(stmt) && stmt.name) {\n      defs.push(makeTsDefinition(stmt.name.text, 'enum', stmt, sourceFile, content));\n    } else if (ts.isTypeAliasDeclaration(stmt) && ts.isIdentifier(stmt.name)) {\n      defs.push(makeTsDefinition(stmt.name.text, 'type-alias', stmt, sourceFile, content));\n    } else if (ts.isVariableStatement(stmt)) {\n      for (const decl of stmt.declarationList.declarations) {\n        if (ts.isIdentifier(decl.name)) {\n          defs.push(makeTsDefinition(decl.name.text, 'variable', stmt, sourceFile, content));\n        }\n      }\n    }\n  }\n\n  return defs;\n}\n\nfunction makeTsDefinition(name: string, type: string, node: ts.Node, sf: ts.SourceFile, text: string): Definition {\n  const start = node.getStart();\n  const end = node.getEnd();\n  const line = sf.getLineAndCharacterOfPosition(start).line + 1;\n  const code = text.slice(start, end);\n  const body = (node as any).body as ts.Node | undefined;\n  const search = body ? body.getText(sf) : code;\n  return { name, type, start, end, line, code, search };\n}\n\nfunction extractPythonDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n\n  function blockEnd(startLine: number, indent: number): number {\n    let line = startLine;\n    for (; line < lines.length; line++) {\n      const current = lines[line];\n      if (current.trim() === '') continue;\n      const currentIndent = current.match(/^\\s*/)?.[0].length ?? 0;\n      if (currentIndent <= indent) break;\n    }\n    return line;\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    const indent = line.match(/^\\s*/)?.[0].length ?? 0;\n    const trimmed = line.trim();\n\n    if (indent === 0 && /^def\\s+(\\w+)/.test(trimmed)) {\n      const name = RegExp.$1;\n      const endLine = blockEnd(i + 1, indent);\n      const start = offsets[i];\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const search = code.split(/\\r?\\n/).slice(1).join('\\n');\n      defs.push({ name, type: 'function', start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (indent === 0 && /^class\\s+(\\w+)/.test(trimmed)) {\n      const name = RegExp.$1;\n      const endLine = blockEnd(i + 1, indent);\n      const start = offsets[i];\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const search = code.split(/\\r?\\n/).slice(1).join('\\n');\n      defs.push({ name, type: 'class', start, end, line: i + 1, code, search });\n\n      for (let j = i + 1; j < endLine; j++) {\n        const inner = lines[j];\n        const innerIndent = inner.match(/^\\s*/)?.[0].length ?? 0;\n        const innerTrim = inner.trim();\n        if (innerIndent > indent && /^def\\s+(\\w+)/.test(innerTrim)) {\n          const mName = RegExp.$1;\n          const mEnd = blockEnd(j + 1, innerIndent);\n          const mStart = offsets[j];\n          const mEndPos = offsets[mEnd] ?? content.length;\n          const mCode = content.slice(mStart, mEndPos);\n          const mSearch = mCode.split(/\\r?\\n/).slice(1).join('\\n');\n          defs.push({ name: mName, type: 'method', start: mStart, end: mEndPos, line: j + 1, code: mCode, search: mSearch });\n          j = mEnd - 1;\n        }\n      }\n      i = endLine - 1;\n    } else if (indent === 0 && /^(\\w+)/.test(trimmed) && trimmed.includes('=')) {\n      const name = RegExp.$1;\n      const start = offsets[i];\n      const end = start + line.length;\n      const code = content.slice(start, end);\n      const search = code;\n      defs.push({ name, type: 'variable', start, end, line: i + 1, code, search });\n    }\n  }\n\n  return defs;\n}\n\nfunction extractRubyDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n  const contextStack: Array<{ endLine: number; segments: string[]; kind: 'module' | 'class' }> = [];\n\n  function sanitized(line: string): string {\n    return line.replace(/#.*$/, '');\n  }\n\n  function blockEnd(startLine: number): number {\n    let depth = 0;\n    for (let line = startLine; line < lines.length; line++) {\n      const clean = sanitized(lines[line]);\n      if (!clean.trim()) {\n        continue;\n      }\n\n      if (line === startLine) {\n        depth += 1;\n      } else {\n        const openers = clean.match(/\\b(class|module|def|if|unless|case|begin|for|while|until|loop)\\b/g);\n        if (openers) {\n          depth += openers.length;\n        }\n        const doMatches = clean.match(/\\bdo\\b/g);\n        if (doMatches) {\n          depth += doMatches.length;\n        }\n      }\n\n      const endMatches = clean.match(/\\bend\\b/g);\n      if (endMatches) {\n        depth -= endMatches.length;\n        if (depth <= 0) {\n          return line + 1;\n        }\n      }\n    }\n    return lines.length;\n  }\n\n  function makeDefinition(name: string, type: string, startLine: number, endLine: number, overrideName?: string): void {\n    const finalName = overrideName ?? name;\n    const start = offsets[startLine];\n    const end = offsets[endLine] ?? content.length;\n    const code = content.slice(start, end);\n    const search = code.split(/\\r?\\n/).slice(1).join('\\n');\n    defs.push({ name: finalName, type, start, end, line: startLine + 1, code, search });\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const rawLine = lines[i];\n    const clean = sanitized(rawLine);\n    const trimmed = clean.trim();\n\n    while (contextStack.length > 0 && i >= contextStack[contextStack.length - 1].endLine) {\n      contextStack.pop();\n    }\n\n    if (!trimmed) {\n      continue;\n    }\n\n    const classMatch = /^class\\s+([A-Za-z_]\\w*(?:::[A-Za-z_]\\w*)*)/.exec(trimmed);\n    if (classMatch) {\n      const endLine = blockEnd(i);\n      const parentSegments = contextStack.length > 0 ? contextStack[contextStack.length - 1].segments : [];\n      const classSegments = classMatch[1].split('::');\n      const segments = [...parentSegments, ...classSegments];\n      const qualified = segments.join('::');\n      makeDefinition(classMatch[1], 'class', i, endLine, qualified);\n      contextStack.push({ endLine, segments, kind: 'class' });\n      continue;\n    }\n\n    const moduleMatch = /^module\\s+([A-Za-z_]\\w*(?:::[A-Za-z_]\\w*)*)/.exec(trimmed);\n    if (moduleMatch) {\n      const endLine = blockEnd(i);\n      const parentSegments = contextStack.length > 0 ? contextStack[contextStack.length - 1].segments : [];\n      const moduleSegments = moduleMatch[1].split('::');\n      const segments = [...parentSegments, ...moduleSegments];\n      const qualified = segments.join('::');\n      makeDefinition(moduleMatch[1], 'module', i, endLine, qualified);\n      contextStack.push({ endLine, segments, kind: 'module' });\n      continue;\n    }\n\n    const defMatch = /^def\\s+([A-Za-z_]\\w*[!?=]?|(?:self|[A-Za-z_]\\w*)\\.[A-Za-z_]\\w*[!?=]?)/.exec(trimmed);\n    if (defMatch) {\n      const endLine = blockEnd(i);\n      const name = defMatch[1];\n      const insideClass = contextStack.some(mx => mx.kind === 'class');\n      const type = insideClass ? 'method' : 'function';\n      makeDefinition(name, type, i, endLine);\n      i = endLine - 1;\n      continue;\n    }\n\n    const constMatch = /^([A-Z][A-Za-z0-9_]*)\\s*=/.exec(trimmed);\n    if (constMatch) {\n      const start = offsets[i];\n      const end = start + rawLine.length;\n      const code = content.slice(start, end);\n      defs.push({ name: constMatch[1], type: 'constant', start, end, line: i + 1, code, search: code });\n    }\n  }\n\n  return defs;\n}\n\nfunction extractRustDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n\n  function blockEnd(startLine: number): number {\n    let braces = 0;\n    let started = false;\n    let line = startLine;\n    for (; line < lines.length; line++) {\n      const current = lines[line];\n      const opens = (current.match(/\\{/g) ?? []).length;\n      const closes = (current.match(/\\}/g) ?? []).length;\n      braces += opens;\n      braces -= closes;\n      if (opens > 0) started = true;\n      if (started && braces === 0) break;\n    }\n    return line + 1;\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    const trimmed = line.trim();\n    const indent = line.match(/^\\s*/)?.[0].length ?? 0;\n\n    const fnMatch = /^(?:pub\\s+)?fn\\s+(\\w+)/.exec(trimmed);\n    const structMatch = /^(?:pub\\s+)?struct\\s+(\\w+)/.exec(trimmed);\n    const enumMatch = /^(?:pub\\s+)?enum\\s+(\\w+)/.exec(trimmed);\n    const traitMatch = /^(?:pub\\s+)?trait\\s+(\\w+)/.exec(trimmed);\n    const constMatch = /^(?:pub\\s+)?(?:const|static)\\s+(\\w+)/.exec(trimmed);\n\n    if (indent === 0 && fnMatch) {\n      const name = fnMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      defs.push({ name, type: 'function', start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (indent === 0 && structMatch) {\n      const name = structMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      defs.push({ name, type: 'struct', start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (indent === 0 && enumMatch) {\n      const name = enumMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      defs.push({ name, type: 'enum', start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (indent === 0 && traitMatch) {\n      const name = traitMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      defs.push({ name, type: 'trait', start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (indent === 0 && constMatch) {\n      const name = constMatch[1];\n      const start = offsets[i];\n      const end = start + line.length;\n      const code = content.slice(start, end);\n      defs.push({ name, type: 'variable', start, end, line: i + 1, code, search: code });\n    } else if (indent === 0 && /^(?:pub\\s+)?impl\\b/.test(trimmed)) {\n      const endLine = blockEnd(i);\n      for (let j = i + 1; j < endLine; j++) {\n        const inner = lines[j];\n        const innerTrim = inner.trim();\n        const methodMatch = /^(?:pub\\s+)?fn\\s+(\\w+)/.exec(innerTrim);\n        if (methodMatch) {\n          const name = methodMatch[1];\n          const mStart = offsets[j];\n          const mEndLine = blockEnd(j);\n          const mEnd = offsets[mEndLine] ?? content.length;\n          const code = content.slice(mStart, mEnd);\n          const bodyStart = code.indexOf('{');\n          const bodyEnd = code.lastIndexOf('}');\n          const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n          defs.push({ name, type: 'method', start: mStart, end: mEnd, line: j + 1, code, search });\n          j = mEndLine - 1;\n        }\n      }\n      i = endLine - 1;\n    }\n  }\n\n  return defs;\n}\n\nfunction extractGoDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n\n  function blockEnd(startLine: number): number {\n    let braces = 0;\n    let started = false;\n    let line = startLine;\n    for (; line < lines.length; line++) {\n      const current = lines[line];\n      const opens = (current.match(/\\{/g) ?? []).length;\n      const closes = (current.match(/\\}/g) ?? []).length;\n      braces += opens;\n      braces -= closes;\n      if (opens > 0) started = true;\n      if (started && braces === 0) break;\n    }\n    return line + 1;\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    const trimmed = line.trim();\n    const funcMatch = /^func\\s+(?:\\([^)]+\\)\\s*)?(\\w+)/.exec(trimmed);\n    const typeMatch = /^type\\s+(\\w+)/.exec(trimmed);\n    const varMatch = /^(?:var|const)\\s+(\\w+)/.exec(trimmed);\n\n    if (funcMatch) {\n      const name = funcMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n        const code = content.slice(start, end);\n        const bodyStart = code.indexOf('{');\n        const bodyEnd = code.lastIndexOf('}');\n        const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n        const type = trimmed.startsWith('func (') ? 'method' : 'function';\n        defs.push({ name, type, start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (typeMatch) {\n      const name = typeMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n        const code = content.slice(start, end);\n        const bodyStart = code.indexOf('{');\n        const bodyEnd = code.lastIndexOf('}');\n        const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n        const kind = /struct/.test(trimmed) ? 'struct' : /interface/.test(trimmed) ? 'interface' : 'type';\n        defs.push({ name, type: kind, start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (varMatch) {\n      const name = varMatch[1];\n      const start = offsets[i];\n      const end = start + line.length;\n      const code = content.slice(start, end);\n      defs.push({ name, type: 'variable', start, end, line: i + 1, code, search: code });\n    }\n  }\n\n  return defs;\n}\n\nfunction extractCppDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n\n  const strippedLines: string[] = [];\n  let inBlockComment = false;\n  for (const line of lines) {\n    let result = '';\n    for (let i = 0; i < line.length; i++) {\n      const char = line[i];\n      const next = line[i + 1];\n      if (!inBlockComment && char === '/' && next === '/') {\n        break;\n      }\n      if (!inBlockComment && char === '/' && next === '*') {\n        inBlockComment = true;\n        i++;\n        continue;\n      }\n      if (inBlockComment && char === '*' && next === '/') {\n        inBlockComment = false;\n        i++;\n        continue;\n      }\n      if (!inBlockComment) {\n        result += char;\n      }\n    }\n    strippedLines.push(result);\n  }\n\n  function sanitize(line: string): string {\n    return line\n      .replace(/'(?:\\\\.|[^'\\\\])*'/g, \"''\")\n      .replace(/\"(?:\\\\.|[^\"\\\\])*\"/g, '\"\"');\n  }\n\n  function blockEnd(startLine: number): number {\n    let braces = 0;\n    let started = false;\n    for (let line = startLine; line < lines.length; line++) {\n      const sanitized = sanitize(strippedLines[line]);\n      const opens = (sanitized.match(/\\{/g) ?? []).length;\n      const closes = (sanitized.match(/\\}/g) ?? []).length;\n      if (opens > 0) started = true;\n      braces += opens;\n      braces -= closes;\n      if (!started && sanitized.includes(';')) {\n        return line + 1;\n      }\n      if (started && braces <= 0) {\n        return line + 1;\n      }\n    }\n    return lines.length;\n  }\n\n  function pushBlockDefinition(name: string, type: string, startLine: number): void {\n    const start = offsets[startLine];\n    const endLine = blockEnd(startLine);\n    const end = offsets[endLine] ?? content.length;\n    const code = content.slice(start, end);\n    let search = code;\n    const bodyStart = code.indexOf('{');\n    const bodyEnd = code.lastIndexOf('}');\n    if (bodyStart >= 0 && bodyEnd >= bodyStart) {\n      search = code.slice(bodyStart + 1, bodyEnd);\n    }\n    defs.push({ name, type, start, end, line: startLine + 1, code, search });\n  }\n\n  function pushVariable(name: string, startLine: number): void {\n    const start = offsets[startLine];\n    const end = start + lines[startLine].length;\n    const code = content.slice(start, end);\n    defs.push({ name, type: 'variable', start, end, line: startLine + 1, code, search: code });\n  }\n\n  const classStack: Array<{ name: string; endLine: number }> = [];\n  let pendingFunction: { startLine: number; signature: string; className?: string } | null = null;\n  let braceDepth = 0;\n\n  function currentClass(): string | undefined {\n    return classStack.length ? classStack[classStack.length - 1]?.name : undefined;\n  }\n\n  function resetPending(): void {\n    pendingFunction = null;\n  }\n\n  function appendPending(text: string): void {\n    if (!pendingFunction || !text) return;\n    if (pendingFunction.signature) pendingFunction.signature += ' ';\n    pendingFunction.signature += text;\n  }\n\n  function parsePending(): { name: string; type: string } | null {\n    if (!pendingFunction) return null;\n    const normalized = pendingFunction.signature.replace(/\\s+/g, ' ').trim();\n    const parenIndex = normalized.indexOf('(');\n    if (parenIndex === -1) return null;\n    const before = normalized.slice(0, parenIndex).trim();\n    if (!before) return null;\n    const tokens = before.split(/\\s+/);\n    if (tokens.length === 0) return null;\n    let candidate = tokens[tokens.length - 1];\n    candidate = candidate.replace(/[*&]+$/, '');\n    const namePart = (candidate.split('::').pop() ?? candidate).replace(/[*&]+$/, '');\n    if (!/^~?[A-Za-z_]\\w*$/.test(namePart)) return null;\n    if (/^(?:if|for|while|switch|catch|return|sizeof|throw|case|else|do)$/.test(namePart)) return null;\n    const type = (pendingFunction.className || candidate.includes('::')) ? 'method' : 'function';\n    return { name: namePart, type };\n  }\n\n  function maybeFunctionStart(line: string): boolean {\n    if (!line.includes('(')) return false;\n    if (/^(?:if|for|while|switch|catch|return|sizeof|throw|case|else|do)\\b/.test(line)) return false;\n    if (/^(?:using|typedef)\\b/.test(line)) return false;\n    return true;\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    while (classStack.length && classStack[classStack.length - 1]?.endLine <= i) {\n      classStack.pop();\n    }\n\n    const stripped = strippedLines[i];\n    const trimmed = stripped.trim();\n    const sanitizedLine = sanitize(stripped);\n\n    if (pendingFunction) {\n      appendPending(trimmed);\n      if (sanitizedLine.includes('{')) {\n        const parsed = parsePending();\n        if (parsed) {\n          pushBlockDefinition(parsed.name, parsed.type, pendingFunction.startLine);\n        }\n        resetPending();\n      } else if (/;\\s*$/.test(trimmed)) {\n        resetPending();\n      }\n    } else if (trimmed && !trimmed.startsWith('#')) {\n      const classMatch = /^(?:typedef\\s+)?(?:template\\s*<[^>]+>\\s*)*(class|struct|union)\\s+([A-Za-z_]\\w*)/.exec(trimmed);\n      if (classMatch && sanitizedLine.includes('{')) {\n        const name = classMatch[2];\n        const type = classMatch[1];\n        const endLine = blockEnd(i);\n        pushBlockDefinition(name, type, i);\n        classStack.push({ name, endLine });\n      } else {\n        const enumMatch = /^(?:typedef\\s+)?(?:template\\s*<[^>]+>\\s*)*enum(?:\\s+(?:class|struct))?\\s+([A-Za-z_]\\w*)/.exec(trimmed);\n        if (enumMatch && sanitizedLine.includes('{')) {\n          pushBlockDefinition(enumMatch[1], 'enum', i);\n        } else if (\n          braceDepth === 0 &&\n          !trimmed.includes('(') &&\n          !/^(?:class|struct|union|enum|template|typedef)\\b/.test(trimmed)\n        ) {\n          const varMatch = /^(?:constexpr\\s+|const\\s+|static\\s+|inline\\s+|extern\\s+|volatile\\s+|register\\s+|thread_local\\s+)*[A-Za-z_]\\w*[\\w\\s:<>,*&]*\\s+([A-Za-z_]\\w*)\\s*(?:=\\s*[^;]+)?;$/.exec(trimmed);\n          if (varMatch) {\n            pushVariable(varMatch[1], i);\n          }\n        }\n\n        if (maybeFunctionStart(trimmed)) {\n          pendingFunction = { startLine: i, signature: trimmed, className: currentClass() };\n          if (sanitizedLine.includes('{')) {\n            const parsed = parsePending();\n            if (parsed) {\n              pushBlockDefinition(parsed.name, parsed.type, pendingFunction.startLine);\n            }\n            resetPending();\n          }\n        }\n      }\n    }\n\n    const opens = (sanitizedLine.match(/\\{/g) ?? []).length;\n    const closes = (sanitizedLine.match(/\\}/g) ?? []).length;\n    braceDepth += opens;\n    braceDepth -= closes;\n  }\n\n  return defs;\n}\n\nfunction extractSolidityDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n\n  function blockEnd(startLine: number): number {\n    let braces = 0;\n    let started = false;\n    let line = startLine;\n    for (; line < lines.length; line++) {\n      const current = lines[line];\n      const cleaned = current.replace(/\\/\\/.*$/, '');\n      const opens = (cleaned.match(/\\{/g) ?? []).length;\n      const closes = (cleaned.match(/\\}/g) ?? []).length;\n      if (!started && opens > 0) started = true;\n      braces += opens;\n      braces -= closes;\n      if (!started && cleaned.includes(';')) {\n        return line + 1;\n      }\n      if (started && braces <= 0) {\n        return line + 1;\n      }\n    }\n    return lines.length;\n  }\n\n  function pushDefinition(name: string, type: string, startLine: number): void {\n    const start = offsets[startLine];\n    const endLine = blockEnd(startLine);\n    const end = offsets[endLine] ?? content.length;\n    const code = content.slice(start, end);\n    const bodyStart = code.indexOf('{');\n    const bodyEnd = code.lastIndexOf('}');\n    const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n    defs.push({ name, type, start, end, line: startLine + 1, code, search });\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    const cleaned = line.replace(/\\/\\/.*$/, '');\n    const trimmed = cleaned.trim();\n    if (!trimmed) continue;\n\n    const contractMatch = /^(?:abstract\\s+)?(contract|interface|library)\\s+([A-Za-z_][\\w]*)/.exec(trimmed);\n    if (contractMatch) {\n      const type = contractMatch[1];\n      const name = contractMatch[2];\n      pushDefinition(name, type, i);\n\n      let braceDepth = (trimmed.match(/\\{/g) ?? []).length - (trimmed.match(/\\}/g) ?? []).length;\n      const endLine = blockEnd(i);\n      for (let j = i + 1; j < endLine; j++) {\n        const innerLine = lines[j];\n        const innerClean = innerLine.replace(/\\/\\/.*$/, '');\n        const innerTrim = innerClean.trim();\n        const beforeDepth = braceDepth;\n        const opens = (innerClean.match(/\\{/g) ?? []).length;\n        const closes = (innerClean.match(/\\}/g) ?? []).length;\n\n        if (beforeDepth >= 1 && innerTrim) {\n          let memberName: string | undefined;\n          let memberType: string | undefined;\n\n          const fnMatch = /function\\s+([A-Za-z_][\\w]*)/.exec(innerTrim);\n          if (fnMatch) {\n            memberName = fnMatch[1];\n            memberType = 'function';\n          } else if (/^constructor\\s*\\(/.test(innerTrim)) {\n            memberName = 'constructor';\n            memberType = 'constructor';\n          } else {\n            const modifierMatch = /modifier\\s+([A-Za-z_][\\w]*)/.exec(innerTrim);\n            if (modifierMatch) {\n              memberName = modifierMatch[1];\n              memberType = 'modifier';\n            } else {\n              const eventMatch = /event\\s+([A-Za-z_][\\w]*)/.exec(innerTrim);\n              if (eventMatch) {\n                memberName = eventMatch[1];\n                memberType = 'event';\n              } else {\n                const structMatch = /struct\\s+([A-Za-z_][\\w]*)/.exec(innerTrim);\n                if (structMatch) {\n                  memberName = structMatch[1];\n                  memberType = 'struct';\n                } else {\n                  const enumMatch = /enum\\s+([A-Za-z_][\\w]*)/.exec(innerTrim);\n                  if (enumMatch) {\n                    memberName = enumMatch[1];\n                    memberType = 'enum';\n                  } else {\n                    const errorMatch = /error\\s+([A-Za-z_][\\w]*)/.exec(innerTrim);\n                    if (errorMatch) {\n                      memberName = errorMatch[1];\n                      memberType = 'error';\n                    }\n                  }\n                }\n              }\n            }\n          }\n\n          if (memberName && memberType) {\n            pushDefinition(memberName, memberType, j);\n          }\n        }\n\n        braceDepth += opens;\n        braceDepth -= closes;\n      }\n\n      i = endLine - 1;\n      continue;\n    }\n\n    const freeFnMatch = /^function\\s+([A-Za-z_][\\w]*)/.exec(trimmed);\n    if (freeFnMatch) {\n      pushDefinition(freeFnMatch[1], 'function', i);\n      continue;\n    }\n\n    const globalStructMatch = /^(struct|enum|error)\\s+([A-Za-z_][\\w]*)/.exec(trimmed);\n    if (globalStructMatch) {\n      pushDefinition(globalStructMatch[2], globalStructMatch[1], i);\n    }\n  }\n\n  return defs;\n}\n\nfunction escapeRegExp(str: string): string {\n  return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\nfunction extractJavaDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n\n  function blockEnd(startLine: number): number {\n    let braces = 0;\n    let started = false;\n    let line = startLine;\n    for (; line < lines.length; line++) {\n      const current = lines[line];\n      const cleaned = current.replace(/\".*?\"/g, '');\n      const opens = (cleaned.match(/\\{/g) ?? []).length;\n      const closes = (cleaned.match(/\\}/g) ?? []).length;\n      braces += opens;\n      braces -= closes;\n      if (opens > 0) started = true;\n      if (started && braces === 0) break;\n    }\n    return line + 1;\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    const trimmed = line.trim();\n    const cleaned = trimmed.replace(/\\/\\/.*$/, '');\n\n    const classMatch = /^(?:public\\s+|protected\\s+|private\\s+)?(?:abstract\\s+|final\\s+)?class\\s+([\\w$]+)/.exec(cleaned);\n    const interfaceMatch = /^(?:public\\s+|protected\\s+|private\\s+)?interface\\s+([\\w$]+)/.exec(cleaned);\n    const enumMatch = /^(?:public\\s+|protected\\s+|private\\s+)?enum\\s+([\\w$]+)/.exec(cleaned);\n\n    if (classMatch) {\n      const name = classMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      defs.push({ name, type: 'class', start, end, line: i + 1, code, search });\n\n      let braceDepth = 0;\n      for (let j = i + 1; j < endLine; j++) {\n        const inner = lines[j];\n        const innerClean = inner.trim().replace(/\\/\\/.*$/, '');\n        const opens = (innerClean.match(/\\{/g) ?? []).length;\n        const closes = (innerClean.match(/\\}/g) ?? []).length;\n\n        if (braceDepth === 0) {\n          const methodMatch = /^(?:public|protected|private|static|final|abstract|synchronized|native|strictfp|default|\\s)*(?:<[^>]+>\\s*)?(?:[\\w$]+\\s+)*([\\w$]+)\\s*\\(/.exec(innerClean);\n          const name = methodMatch?.[1];\n          if (name && !['if', 'for', 'while', 'switch', 'catch'].includes(name)) {\n            const mStart = offsets[j];\n            const mEndLine = blockEnd(j);\n            const mEnd = offsets[mEndLine] ?? content.length;\n            const mCode = content.slice(mStart, mEnd);\n            const bodyStart = mCode.indexOf('{');\n            const bodyEnd = mCode.lastIndexOf('}');\n            const search = bodyStart >= 0 && bodyEnd >= bodyStart ? mCode.slice(bodyStart + 1, bodyEnd) : mCode;\n            const type = name === classMatch[1] ? 'constructor' : 'method';\n            defs.push({ name, type, start: mStart, end: mEnd, line: j + 1, code: mCode, search });\n            j = mEndLine - 1;\n            braceDepth = 0;\n            continue;\n          }\n        }\n\n        braceDepth += opens;\n        braceDepth -= closes;\n      }\n\n      i = endLine - 1;\n    } else if (interfaceMatch) {\n      const name = interfaceMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      defs.push({ name, type: 'interface', start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    } else if (enumMatch) {\n      const name = enumMatch[1];\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      defs.push({ name, type: 'enum', start, end, line: i + 1, code, search });\n      i = endLine - 1;\n    }\n  }\n\n  return defs;\n}\n\nfunction extractCSharpDefinitions(content: string): Definition[] {\n  const { lines, offsets } = getLinesAndOffsets(content);\n\n  const defs: Definition[] = [];\n\n  function blockEnd(startLine: number): number {\n    let braces = 0;\n    let started = false;\n    let line = startLine;\n    for (; line < lines.length; line++) {\n      const current = lines[line];\n      const cleaned = current.replace(/\".*?\"/g, '').replace(/\\/\\/.*$/, '');\n      const opens = (cleaned.match(/\\{/g) ?? []).length;\n      const closes = (cleaned.match(/\\}/g) ?? []).length;\n      braces += opens;\n      braces -= closes;\n      if (opens > 0) started = true;\n      if (started && braces === 0) break;\n    }\n    return started ? line + 1 : startLine + 1;\n  }\n\n  const modifierSet = new Set([\n    'public',\n    'internal',\n    'protected',\n    'private',\n    'partial',\n    'static',\n    'sealed',\n    'abstract',\n    'unsafe',\n    'new',\n    'readonly',\n    'ref',\n    'virtual',\n    'override',\n    'async',\n    'extern'\n  ]);\n  const keywordBlockers = new Set(['if', 'for', 'foreach', 'while', 'switch', 'catch', 'using', 'lock']);\n\n  function stripAttributes(text: string): string {\n    let current = text.trim();\n    while (current.startsWith('[')) {\n      const close = current.indexOf(']');\n      if (close === -1) break;\n      current = current.slice(close + 1).trimStart();\n    }\n    return current;\n  }\n\n  function skipModifiers(tokens: string[]): number {\n    let index = 0;\n    while (index < tokens.length && modifierSet.has(tokens[index])) {\n      index++;\n    }\n    return index;\n  }\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    const trimmed = line.trim();\n    if (!trimmed) continue;\n\n    const noComment = trimmed.replace(/\\/\\/.*$/, '');\n    if (!noComment) continue;\n\n    const signature = stripAttributes(noComment);\n    if (!signature) continue;\n\n    const tokens = signature.split(/\\s+/);\n    if (tokens.length === 0) continue;\n\n    const startIndex = skipModifiers(tokens);\n    const keyword = tokens[startIndex];\n\n    if (!keyword) continue;\n\n    if (keyword === 'record') {\n      const recordKind = tokens[startIndex + 1] === 'class' || tokens[startIndex + 1] === 'struct'\n        ? tokens[startIndex + 1]\n        : undefined;\n      const nameToken = tokens[startIndex + (recordKind ? 2 : 1)];\n      if (nameToken) {\n        const name = nameToken.replace(/[<({].*$/, '');\n        const start = offsets[i];\n        const endLine = blockEnd(i);\n        const end = offsets[endLine] ?? content.length;\n        const code = content.slice(start, end);\n        const bodyStart = code.indexOf('{');\n        const bodyEnd = code.lastIndexOf('}');\n        const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n        defs.push({ name, type: 'record', start, end, line: i + 1, code, search });\n        i = endLine - 1;\n        continue;\n      }\n    } else if (keyword === 'class' || keyword === 'struct' || keyword === 'interface' || keyword === 'enum') {\n      const nameToken = tokens[startIndex + 1];\n      if (!nameToken) continue;\n      const name = nameToken.replace(/[<({].*$/, '');\n      const start = offsets[i];\n      const endLine = blockEnd(i);\n      const end = offsets[endLine] ?? content.length;\n      const code = content.slice(start, end);\n      const bodyStart = code.indexOf('{');\n      const bodyEnd = code.lastIndexOf('}');\n      const search = bodyStart >= 0 && bodyEnd >= bodyStart ? code.slice(bodyStart + 1, bodyEnd) : code;\n      const type = keyword === 'class' ? 'class' : keyword === 'struct' ? 'struct' : keyword === 'interface' ? 'interface' : 'enum';\n      defs.push({ name, type, start, end, line: i + 1, code, search });\n\n      if (keyword === 'class' || keyword === 'struct') {\n        let braceDepth = 0;\n        for (let j = i + 1; j < endLine; j++) {\n          const inner = lines[j];\n          const innerTrim = inner.trim();\n          if (!innerTrim) continue;\n\n          const innerNoComment = innerTrim.replace(/\\/\\/.*$/, '');\n          if (!innerNoComment) continue;\n\n          const innerSignature = stripAttributes(innerNoComment);\n          if (!innerSignature) continue;\n\n          const opens = (innerSignature.match(/\\{/g) ?? []).length;\n          const closes = (innerSignature.match(/\\}/g) ?? []).length;\n\n          if (braceDepth <= 1 && innerSignature.includes('(')) {\n            const parenIndex = innerSignature.indexOf('(');\n            const before = innerSignature.slice(0, parenIndex).trim();\n            if (before && !before.includes('=')) {\n              const beforeTokens = before.split(/\\s+/);\n              const candidateRaw = beforeTokens[beforeTokens.length - 1];\n              const candidate = candidateRaw?.replace(/<.*$/, '');\n              if (candidate && !keywordBlockers.has(candidate)) {\n                const mStart = offsets[j];\n                const mEndLine = blockEnd(j);\n                const mEnd = offsets[mEndLine] ?? content.length;\n                const mCode = content.slice(mStart, mEnd);\n                const bodyStart = mCode.indexOf('{');\n                const bodyEnd = mCode.lastIndexOf('}');\n                const search = bodyStart >= 0 && bodyEnd >= bodyStart ? mCode.slice(bodyStart + 1, bodyEnd) : mCode;\n                const typeName = candidate === name ? 'constructor' : 'method';\n                defs.push({ name: candidate, type: typeName, start: mStart, end: mEnd, line: j + 1, code: mCode, search });\n                if (innerSignature.includes('{')) {\n                  j = mEndLine - 1;\n                  braceDepth = 0;\n                  continue;\n                }\n              }\n            }\n          }\n\n          braceDepth += opens;\n          braceDepth -= closes;\n        }\n      }\n\n      i = endLine - 1;\n      continue;\n    }\n\n    if (/^(?:public|internal|protected|private|const|static|readonly)/.test(signature) && signature.includes('=')) {\n      const equalIndex = signature.indexOf('=');\n      if (equalIndex > 0) {\n        const before = signature.slice(0, equalIndex).trim();\n        const candidate = before.split(/\\s+/).pop();\n        if (candidate && /^[A-Za-z_][\\w]*$/.test(candidate)) {\n          const name = candidate;\n          const start = offsets[i];\n          const end = start + line.length;\n          const code = content.slice(start, end);\n          defs.push({ name, type: 'variable', start, end, line: i + 1, code, search: code });\n        }\n      }\n    }\n  }\n\n  return defs;\n}\n","/**\n * Simplified Pipeline State Machine\n * \n * A cleaner implementation that removes support for nested retries,\n * which analysis showed are pathological and shouldn't exist.\n * \n * Key simplifications:\n * - Single active retry context (no stack)\n * - Context reuse for same retry pattern\n * - No parent context tracking\n * - Clearer semantics\n */\n\n/**\n * Retry Context - Just one at a time\n */\n/**\n * Retry Context\n * WHY: Track a single active retry pattern to avoid pathological nested retries.\n * CONTEXT: The requesting stage asks to retry a specific upstream stage; attempts and hints\n *          are local to this context and cleared when the requesting stage completes.\n */\nimport type { StructuredValue } from '../../utils/structured-value';\nimport { isStructuredValue, wrapStructured } from '../../utils/structured-value';\nimport { inheritExpressionProvenance } from '../../utils/expression-provenance';\n\nexport interface RetryContext {\n  id: string;                    // Unique context ID\n  requestingStage: number;       // Stage that requested retry\n  retryingStage: number;         // Stage being retried\n  attemptNumber: number;         // Current attempt (1-based)\n  allAttempts: StructuredValue[];         // All outputs from retry attempts\n  hints?: string[];              // Hints provided per retry request\n  currentHint?: string;          // Last hint provided by requesting stage\n}\n\n/**\n * Pipeline Events - Same as before for compatibility\n */\nexport type PipelineEvent =\n  | { type: 'PIPELINE_START'; input: string; structuredInput?: StructuredValue }\n  | { type: 'STAGE_START'; stage: number; input: string; structuredInput?: StructuredValue; contextId?: string }\n  | { type: 'STAGE_SUCCESS'; stage: number; output: string; structuredOutput?: StructuredValue; contextId?: string }\n  | { \n      type: 'STAGE_RETRY_REQUEST';\n      requestingStage: number;\n      targetStage: number;\n      contextId: string;\n    }\n  | { type: 'STAGE_FAILURE'; stage: number; error: Error }\n  | { type: 'PIPELINE_COMPLETE'; output: string }\n  | { type: 'PIPELINE_ABORT'; reason: string };\n\n/**\n * Pipeline State\n */\n/**\n * Pipeline State\n * WHY: Centralize stage progression, retry limits, and history needed to build @p/@mx.\n * GOTCHA: We store a single activeRetryContext by design; nested retries are not supported.\n */\nexport interface PipelineState {\n  status: 'IDLE' | 'RUNNING' | 'RETRYING' | 'COMPLETED' | 'FAILED';\n  currentStage: number;\n  currentInput: string;\n  baseInput: string;\n  currentStructuredInput?: StructuredValue;\n  baseStructuredInput?: StructuredValue;\n  events: PipelineEvent[];\n  stageStructuredOutputs: Map<number, StructuredValue>;\n  \n  // Simplified retry tracking\n  activeRetryContext?: RetryContext;  // Just one active context\n  globalStageRetryCount: Map<number, number>;   // Global safety limit\n  \n  // For @pipeline.retries.all accumulation\n  allRetryHistory: Map<string, StructuredValue[]>;       // contextId → all outputs\n}\n\n/**\n * Actions and Results - Same interfaces for compatibility\n */\nexport type PipelineAction =\n  | { type: 'START'; input: string; structuredInput?: StructuredValue }\n  | { type: 'STAGE_RESULT'; result: StageResult }\n  | { type: 'ABORT'; reason: string };\n\nexport type StageResult =\n  | { type: 'success'; output: string; structuredOutput?: StructuredValue }\n  | { type: 'retry'; reason?: string; from?: number; hint?: any }\n  | { type: 'error'; error: Error };\n\nexport type NextStep =\n  | { type: 'EXECUTE_STAGE'; stage: number; input: string; structuredInput?: StructuredValue; context: StageContext }\n  | { type: 'COMPLETE'; output: string }\n  | { type: 'ERROR'; stage: number; error: Error }\n  | { type: 'ABORT'; reason: string }\n  | { type: 'INVALID_ACTION' };\n\n/**\n * Simplified Stage Context\n */\nexport interface StageContext {\n  stage: number;                  // 1-indexed stage number\n  attempt: number;                 // Global attempt count for this stage\n  contextAttempt: number;          // Attempt within current retry context\n  history: string[];               // Previous outputs from this stage\n  historyStructured?: StructuredValue[];               // Structured view of history\n  previousOutputs: string[];       // Outputs from stages 0..stage-1\n  previousStructuredOutputs?: Array<StructuredValue | undefined>; // Structured outputs\n  globalAttempt: number;           // Total retries across all stages\n  totalStages: number;\n  outputs: Record<number, string>; // Array-style access\n  structuredOutputs?: Record<number, StructuredValue | undefined>;\n  contextId?: string;              // Current retry context ID\n  hintHistory?: string[];          // Hints observed in this retry context\n  currentHint?: string;            // Last hint for this retry cycle\n  baseStructuredInput?: StructuredValue;\n  currentStructuredInput?: StructuredValue;\n}\n\n/**\n * Simplified Pipeline State Machine\n */\n/**\n * Pipeline State Machine\n * WHY: Provide deterministic transitions for stage execution and simplified retry semantics.\n * CONTEXT: Only one active retry context is allowed. Stage N can request a retry of stage N-1.\n * GOTCHA: Stage 0 can only be retried if its source is a function; literals are not retryable.\n */\nexport class PipelineStateMachine {\n  private state: PipelineState;\n  private readonly maxRetriesPerContext = 10;\n  private readonly maxGlobalRetriesPerStage = 20;\n  private readonly totalStages: number;\n  private readonly isStage0Retryable: boolean;\n  private stage0Exhausted: boolean = false;\n  private stage0BaseOutput: string | null = null;\n  private stage0BaseStructuredOutput: StructuredValue | null = null;\n  private readonly hasStage0Replay: boolean;\n  private stage0RetryConsumed: boolean = false;\n\n  constructor(totalStages: number, isStage0Retryable: boolean = false, hasStage0Replay: boolean = false) {\n    this.totalStages = totalStages;\n    this.isStage0Retryable = isStage0Retryable;\n    this.hasStage0Replay = hasStage0Replay;\n    this.state = this.initialState();\n  }\n\n  private initialState(): PipelineState {\n    return {\n      status: 'IDLE',\n      currentStage: 0,\n      currentInput: '',\n      baseInput: '',\n      currentStructuredInput: undefined,\n      baseStructuredInput: undefined,\n      events: [],\n      stageStructuredOutputs: new Map(),\n      activeRetryContext: undefined,\n      globalStageRetryCount: new Map(),\n      allRetryHistory: new Map()\n    };\n  }\n\n  /**\n   * Public API - matches original interface\n   */\n  getTotalStages(): number {\n    return this.totalStages;\n  }\n\n  getEvents(): ReadonlyArray<PipelineEvent> {\n    return [...this.state.events];\n  }\n\n  getStatus(): PipelineState['status'] {\n    return this.state.status;\n  }\n\n  /**\n   * Get all retry history for simplified implementation\n   */\n  getAllRetryHistory(): Map<string, StructuredValue[]> {\n    return new Map(\n      Array.from(this.state.allRetryHistory.entries()).map(([contextId, attempts]) => [\n        contextId,\n        attempts.map(cloneStructuredValue)\n      ])\n    );\n  }\n\n  /**\n   * Main state transition function\n   */\n  /**\n   * Transition the state machine based on the latest action.\n   * WHY: Decouple stage execution from state mutations to keep behavior predictable.\n   */\n  transition(action: PipelineAction): NextStep {\n    switch (action.type) {\n      case 'START':\n        return this.handleStart(action.input, action.structuredInput);\n      case 'STAGE_RESULT':\n        return this.handleStageResult(action.result);\n      case 'ABORT':\n        return this.handleAbort(action.reason);\n      default:\n        return { type: 'INVALID_ACTION' };\n    }\n  }\n\n  /**\n   * Initialize pipeline execution for the first stage.\n   * CONTEXT: Records PIPELINE_START and first STAGE_START events and seeds baseInput.\n   */\n  private handleStart(input: string, structuredInput?: StructuredValue): NextStep {\n    if (this.state.status !== 'IDLE') {\n      return { type: 'INVALID_ACTION' };\n    }\n\n    // Initialize pipeline\n    const initialStructured = structuredInput ? cloneStructuredValue(structuredInput) : undefined;\n    this.state.baseStructuredInput = initialStructured;\n    this.state.currentStructuredInput = initialStructured;\n    this.recordEvent({ type: 'PIPELINE_START', input, structuredInput: initialStructured });\n    this.state.status = 'RUNNING';\n    this.state.currentStage = 0;\n    this.state.currentInput = input;\n    this.state.baseInput = input;\n    this.stage0BaseOutput = input;\n    this.stage0BaseStructuredOutput = initialStructured ?? null;\n\n    // Short-circuit empty pipelines\n    if (this.totalStages === 0) {\n      this.state.status = 'COMPLETED';\n      this.recordEvent({ type: 'PIPELINE_COMPLETE', output: input });\n      return { type: 'COMPLETE', output: input };\n    }\n\n    // Start first stage\n    this.recordEvent({ type: 'STAGE_START', stage: 0, input, structuredInput: initialStructured });\n    \n    return {\n      type: 'EXECUTE_STAGE',\n      stage: 0,\n      input: input,\n      structuredInput: initialStructured,\n      context: this.buildStageContext(0)\n    };\n  }\n\n  /**\n   * Handle the result of a stage: success, retry, or error.\n   * GOTCHA: Success on the retrying stage immediately re-executes the requesting stage.\n   */\n  private handleStageResult(result: StageResult): NextStep {\n    const stage = this.state.currentStage;\n\n    switch (result.type) {\n      case 'success':\n        return this.handleStageSuccess(stage, result.output, result.structuredOutput);\n      case 'retry':\n        return this.handleStageRetry(stage, result.reason, result.from, (result as any).hint);\n      case 'error':\n        return this.handleStageError(stage, result.error);\n    }\n  }\n\n  /**\n   * Process a successful stage output and advance the pipeline.\n   * CONTEXT: When inside a retry context, completing the retried stage schedules the requester.\n   */\n  private handleStageSuccess(stage: number, output: string, structuredOutput?: StructuredValue): NextStep {\n    const context = this.state.activeRetryContext;\n    const wrappedStructured = structuredOutput\n      ? cloneStructuredValue(structuredOutput)\n      : wrapStructured(output, 'text', output);\n    this.state.stageStructuredOutputs.set(stage, wrappedStructured);\n    if (stage === 0) {\n      this.stage0BaseStructuredOutput = wrappedStructured;\n    }\n    \n    // Record success\n    this.recordEvent({ \n      type: 'STAGE_SUCCESS', \n      stage, \n      output,\n      structuredOutput: wrappedStructured,\n      contextId: context?.id \n    });\n\n    // Collect output if this is the retrying stage\n    if (context && stage === context.retryingStage) {\n      context.allAttempts.push(cloneStructuredValue(wrappedStructured));\n    }\n    \n    // Early termination on empty output\n    if (output === '') {\n      this.state.status = 'COMPLETED';\n      this.state.currentStructuredInput = wrappedStructured;\n      this.recordEvent({ type: 'PIPELINE_COMPLETE', output: '' });\n      return { type: 'COMPLETE', output: '' };\n    }\n    \n    // If we're in a retry context and just completed the retrying stage,\n    // re-execute the requesting stage\n    if (context && stage === context.retryingStage) {\n      // Clear the hint before handing control back to the requesting stage\n      context.currentHint = undefined;\n      const nextStage = context.requestingStage;\n      this.state.currentStage = nextStage;\n      this.state.currentInput = output;\n      this.state.currentStructuredInput = wrappedStructured;\n      \n      this.recordEvent({ \n        type: 'STAGE_START', \n        stage: nextStage, \n        input: output,\n        structuredInput: wrappedStructured,\n        contextId: context.id\n      });\n      \n      return {\n        type: 'EXECUTE_STAGE',\n        stage: nextStage,\n        input: output,\n        structuredInput: wrappedStructured,\n        context: this.buildStageContext(nextStage)\n      };\n    }\n    \n    // Clear retry context when requesting stage completes successfully\n    if (context && stage === context.requestingStage) {\n      // Save attempts to history before clearing\n      this.state.allRetryHistory.set(\n        context.id,\n        context.allAttempts.map(attempt => cloneStructuredValue(attempt))\n      );\n      this.state.activeRetryContext = undefined;\n    }\n\n    // Normal progression to next stage\n    const nextStage = stage + 1;\n    \n    // Check if pipeline complete\n    if (nextStage >= this.totalStages) {\n      this.state.status = 'COMPLETED';\n      this.state.currentStructuredInput = wrappedStructured;\n      this.recordEvent({ type: 'PIPELINE_COMPLETE', output });\n      return { type: 'COMPLETE', output };\n    }\n\n    // Continue to next stage\n    this.state.currentStage = nextStage;\n    this.state.currentInput = output;\n    this.state.currentStructuredInput = wrappedStructured;\n\n    this.recordEvent({ \n      type: 'STAGE_START', \n      stage: nextStage, \n      input: output,\n      structuredInput: wrappedStructured,\n      contextId: context?.id\n    });\n\n    return {\n      type: 'EXECUTE_STAGE',\n      stage: nextStage,\n      input: output,\n      structuredInput: wrappedStructured,\n      context: this.buildStageContext(nextStage)\n    };\n  }\n\n  /**\n   * Handle a retry request from the requesting stage.\n   * WHY: Only upstream retries are allowed to keep the model simple and predictable.\n   * GOTCHA: Targeting stage 0 requires a function source; otherwise we abort with guidance.\n   */\n  private handleStageRetry(stage: number, reason?: string, fromOverride?: number, hint?: any): NextStep {\n    const targetStage = fromOverride ?? Math.max(0, stage - 1);\n    \n    if (process.env.MLLD_DEBUG === 'true') {\n      console.error('[SimplifiedStateMachine] handleStageRetry:', {\n        requestingStage: stage,\n        targetStage,\n        hasActiveContext: !!this.state.activeRetryContext,\n        contextRequestingStage: this.state.activeRetryContext?.requestingStage,\n        contextRetryingStage: this.state.activeRetryContext?.retryingStage,\n        willReuseContext: this.state.activeRetryContext?.requestingStage === stage && \n                         this.state.activeRetryContext?.retryingStage === targetStage\n      });\n    }\n    \n    // Special case: Stage 0 self-retry (synthetic source retrying itself)\n    if (stage === 0 && targetStage === 0) {\n      // Non-replayable source: consume retry once and return base input without looping\n      if (!this.hasStage0Replay) {\n        // Only allow a single no-op retry; subsequent requests short-circuit\n        if (this.stage0RetryConsumed) {\n          return this.advanceToNextStage(this.state.baseInput, this.stage0BaseStructuredOutput ?? undefined);\n        }\n        this.stage0RetryConsumed = true;\n        this.stage0Exhausted = true;\n        // Do not increment global retry count; just record the request\n        this.recordEvent({\n          type: 'STAGE_RETRY_REQUEST',\n          requestingStage: 0,\n          targetStage: 0,\n          contextId: 'stage0-self-retry'\n        });\n        // Treat base input as the stage 0 output and continue\n        this.recordEvent({\n          type: 'STAGE_SUCCESS',\n          stage: 0,\n          output: this.state.baseInput,\n          structuredOutput: this.stage0BaseStructuredOutput ?? undefined,\n          contextId: 'stage0-self-retry'\n        });\n        this.state.currentStage = 0;\n        this.state.currentInput = this.state.baseInput;\n        this.state.currentStructuredInput = this.stage0BaseStructuredOutput ?? this.state.baseStructuredInput;\n        return this.advanceToNextStage(\n          this.state.baseInput,\n          this.state.currentStructuredInput ?? undefined\n        );\n      }\n      \n      // Use simplified retry tracking for stage 0\n      const globalRetries = this.state.globalStageRetryCount.get(0) || 0;\n      if (globalRetries >= this.maxGlobalRetriesPerStage || this.stage0Exhausted) {\n        return this.handleAbort(`Stage 0 exceeded global retry limit (${this.maxGlobalRetriesPerStage} attempts).`);\n      }\n      \n      // Increment global count\n      this.state.globalStageRetryCount.set(0, globalRetries + 1);\n      \n      // Record retry event\n      this.recordEvent({\n        type: 'STAGE_RETRY_REQUEST',\n        requestingStage: 0,\n        targetStage: 0,\n        contextId: 'stage0-self-retry'\n      });\n      \n      // Re-execute stage 0\n      this.recordEvent({\n        type: 'STAGE_START',\n        stage: 0,\n        input: this.state.baseInput,\n        structuredInput: this.stage0BaseStructuredOutput ?? this.state.baseStructuredInput,\n        contextId: 'stage0-self-retry'\n      });\n      \n      return {\n        type: 'EXECUTE_STAGE',\n        stage: 0,\n        input: this.state.baseInput,\n        structuredInput: this.stage0BaseStructuredOutput ?? this.state.baseStructuredInput,\n        context: this.buildStageContext(0)\n      };\n    }\n    \n    // Check if stage 1 is trying to retry non-retryable stage 0\n    if (targetStage === 0 && !this.isStage0Retryable) {\n      return this.handleAbort('Cannot retry stage 0: input is not a function. Make the source a function to enable retries.');\n    }\n    \n    // Check if we can reuse existing context (same retry pattern)\n    let context = this.state.activeRetryContext;\n    let isReusingContext = false;\n    \n    if (context && \n        context.requestingStage === stage && \n        context.retryingStage === targetStage) {\n      // Reuse existing context - just increment attempt\n      context.attemptNumber++;\n      isReusingContext = true;\n      \n      if (process.env.MLLD_DEBUG === 'true') {\n        console.error('[SimplifiedStateMachine] Reusing context:', {\n          contextId: context.id,\n          attemptNumber: context.attemptNumber\n        });\n      }\n    } else {\n      // Create new context (replacing any existing one)\n      const contextId = this.generateContextId();\n      context = {\n        id: contextId,\n        requestingStage: stage,\n        retryingStage: targetStage,\n        attemptNumber: 1,\n        allAttempts: [],\n        hints: [],\n        currentHint: undefined\n      };\n      \n      // Save previous context's attempts if it exists\n      if (this.state.activeRetryContext) {\n        this.state.allRetryHistory.set(\n          this.state.activeRetryContext.id,\n          [...this.state.activeRetryContext.allAttempts]\n        );\n      }\n      \n      this.state.activeRetryContext = context;\n      \n      if (process.env.MLLD_DEBUG === 'true') {\n        console.error('[SimplifiedStateMachine] Created new context:', {\n          contextId: context.id,\n          requestingStage: stage,\n          retryingStage: targetStage\n        });\n      }\n    }\n    \n    // Check retry limits\n    if (context.attemptNumber > this.maxRetriesPerContext) {\n      const attempts = context.attemptNumber - 1;\n      const hintSuffix = context.currentHint\n        ? ` Hint: ${typeof context.currentHint === 'string' ? context.currentHint : JSON.stringify(context.currentHint).slice(0, 120)}`\n        : '';\n      return this.handleAbort(\n        `Stage ${stage} exceeded retry limit for stage ${targetStage} (${attempts} attempts; max ${this.maxRetriesPerContext}).${hintSuffix}`\n      );\n    }\n    \n    // Check global limit for target stage\n    const globalRetries = this.state.globalStageRetryCount.get(targetStage) || 0;\n    if (globalRetries >= this.maxGlobalRetriesPerStage) {\n      const hintSuffix = context.currentHint\n        ? ` Hint: ${typeof context.currentHint === 'string' ? context.currentHint : JSON.stringify(context.currentHint).slice(0, 120)}`\n        : '';\n      return this.handleAbort(\n        `Stage ${targetStage} exceeded global retry limit (${this.maxGlobalRetriesPerStage} attempts).${hintSuffix}`\n      );\n    }\n    \n    // Increment global count for target stage\n    this.state.globalStageRetryCount.set(targetStage, globalRetries + 1);\n    \n    // Record retry request\n    this.recordEvent({\n      type: 'STAGE_RETRY_REQUEST',\n      requestingStage: stage,\n      targetStage,\n      contextId: context.id\n    });\n    \n    // Store hint on context for next execution\n    if (hint !== undefined || reason) {\n      const toStore = hint !== undefined ? hint : reason;\n      context.currentHint = toStore as any;\n      if (!context.hints) context.hints = [];\n      context.hints.push(toStore as any);\n    }\n    \n    // Get input for retry\n    const retryInput = this.getInputForStage(targetStage);\n    const retryStructuredInput = this.getStructuredInputForStage(targetStage);\n    \n    // Update state\n    this.state.status = 'RETRYING';\n    this.state.currentStage = targetStage;\n    this.state.currentInput = retryInput;\n    this.state.currentStructuredInput = retryStructuredInput;\n    \n    // Record stage start\n    this.recordEvent({\n      type: 'STAGE_START',\n      stage: targetStage,\n      input: retryInput,\n      structuredInput: retryStructuredInput,\n      contextId: context.id\n    });\n    \n    return {\n      type: 'EXECUTE_STAGE',\n      stage: targetStage,\n      input: retryInput,\n      structuredInput: retryStructuredInput,\n      context: this.buildStageContext(targetStage)\n    };\n  }\n\n  /**\n   * Record a stage error and halt execution.\n   */\n  private handleStageError(stage: number, error: Error): NextStep {\n    this.recordEvent({ type: 'STAGE_FAILURE', stage, error });\n    this.state.status = 'FAILED';\n    \n    return {\n      type: 'ERROR',\n      stage,\n      error\n    };\n  }\n\n  /**\n   * Abort the pipeline with a reason (e.g., retry limit, non-retryable source).\n   */\n  private handleAbort(reason: string): NextStep {\n    this.recordEvent({ type: 'PIPELINE_ABORT', reason });\n    this.state.status = 'FAILED';\n    \n    return {\n      type: 'ABORT',\n      reason\n    };\n  }\n\n  /**\n   * Build context for stage execution\n   */\n  /**\n   * Build a user-facing context snapshot for a given stage.\n   * WHY: The executor uses this to construct @mx and @p variables in stage environments.\n   * GOTCHA: Attempt counts are context-local; downstream stages outside a retry context see try=1.\n   */\n  private buildStageContext(stage: number): StageContext {\n    const context = this.state.activeRetryContext;\n    const events = this.state.events;\n    \n    // Build previous outputs\n    const previousOutputs: string[] = [];\n    const previousStructuredOutputs: Array<StructuredValue | undefined> = [];\n    const structuredOutputsRecord: Record<number, StructuredValue | undefined> = {};\n    structuredOutputsRecord[0] = this.stage0BaseStructuredOutput ?? this.state.baseStructuredInput;\n    for (let s = 0; s < stage; s++) {\n      let found = false;\n      for (let i = events.length - 1; i >= 0; i--) {\n        const event = events[i];\n        if (event.type === 'STAGE_SUCCESS' && event.stage === s) {\n          previousOutputs.push(event.output);\n          const structured = event.structuredOutput ?? this.state.stageStructuredOutputs.get(s);\n          previousStructuredOutputs.push(structured ? cloneStructuredValue(structured) : undefined);\n          structuredOutputsRecord[s + 1] = structured ? cloneStructuredValue(structured) : undefined;\n          found = true;\n          break;\n        }\n      }\n      if (!found) {\n        previousOutputs.push('');\n        const structured = this.state.stageStructuredOutputs.get(s);\n        previousStructuredOutputs.push(structured ? cloneStructuredValue(structured) : undefined);\n        structuredOutputsRecord[s + 1] = structured ? cloneStructuredValue(structured) : undefined;\n      }\n    }\n    \n    // Get stage history (context-local)\n    const stageHistory: string[] = [];\n    const stageHistoryStructured: StructuredValue[] = [];\n    if (context && (stage === context.requestingStage || stage === context.retryingStage)) {\n      // Include attempts from current context\n      for (const attempt of context.allAttempts) {\n        const cloned = cloneStructuredValue(attempt);\n        stageHistoryStructured.push(cloned);\n        stageHistory.push(cloned.text);\n      }\n    }\n    \n    // Count attempts - properly track for both requesting and retrying stages\n    let contextAttempt = 1;\n    if (context) {\n      if (stage === context.retryingStage) {\n        // For the retrying stage, count how many times it has executed\n        // This is the initial execution (1) + number of retries (attemptNumber)\n        contextAttempt = context.attemptNumber + 1;\n      } else if (stage === context.requestingStage) {\n        // For the requesting stage, count how many times we've executed it\n        // This is the number of successful retrying stage executions + 1\n        contextAttempt = context.allAttempts.length + 1;\n      }\n      \n      if (process.env.MLLD_DEBUG === 'true') {\n        console.error('[SimplifiedStateMachine] buildStageContext attempt:', {\n          stage,\n          requestingStage: context.requestingStage,\n          retryingStage: context.retryingStage,\n          attemptNumber: context.attemptNumber,\n          allAttemptsLength: context.allAttempts.length,\n          willUseAttempt: stage === context.requestingStage || stage === context.retryingStage,\n          contextAttempt\n        });\n      }\n    }\n    \n    // Global attempt count for this stage\n    const globalStageRetries = this.state.globalStageRetryCount.get(stage) || 0;\n    const attempt = globalStageRetries + 1;\n    if (!context) {\n      // Keep @pipeline.try in sync with actual executions even without an active retry context\n      contextAttempt = attempt;\n    }\n    \n    // Total retries across all stages\n    let totalRetries = 0;\n    for (const count of this.state.globalStageRetryCount.values()) {\n      totalRetries += count;\n    }\n    const globalAttempt = totalRetries + 1;\n    \n    return {\n      stage: stage + 1,  // 1-indexed for user\n      attempt,\n      contextAttempt,\n      history: stageHistory,\n      previousOutputs,\n      globalAttempt,\n      totalStages: this.totalStages,\n      outputs: {\n        0: this.state.baseInput,\n        ...Object.fromEntries(previousOutputs.map((out, i) => [i + 1, out]))\n      },\n      structuredOutputs: structuredOutputsRecord,\n      contextId: context?.id,\n      hintHistory: context?.hints ? [...context.hints] : [],\n      currentHint: context?.currentHint,\n      previousStructuredOutputs,\n      historyStructured: stageHistoryStructured,\n      baseStructuredInput: this.state.baseStructuredInput,\n      currentStructuredInput: this.state.currentStructuredInput\n    };\n  }\n\n  /**\n   * Helper methods\n   */\n  private generateContextId(): string {\n    return `mx-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;\n  }\n\n  private getInputForStage(stage: number): string {\n    if (stage === 0) {\n      return this.state.baseInput;\n    }\n    \n    // Find most recent success for stage-1\n    for (let i = this.state.events.length - 1; i >= 0; i--) {\n      const event = this.state.events[i];\n      if (event.type === 'STAGE_SUCCESS' && event.stage === stage - 1) {\n        return event.output;\n      }\n    }\n    \n    return this.state.baseInput;\n  }\n\n  private getStructuredInputForStage(stage: number): StructuredValue | undefined {\n    if (stage === 0) {\n      return this.state.baseStructuredInput ? cloneStructuredValue(this.state.baseStructuredInput) : undefined;\n    }\n\n    const structured = this.state.stageStructuredOutputs.get(stage - 1);\n    if (structured) {\n      return cloneStructuredValue(structured);\n    }\n\n    return this.state.baseStructuredInput ? cloneStructuredValue(this.state.baseStructuredInput) : undefined;\n  }\n\n  private recordEvent(event: PipelineEvent): void {\n    this.state.events.push(event);\n  }\n\n  /**\n   * Advance to the next stage without creating a retry context.\n   * Used for non-replayable stage-0 retries to avoid spinning.\n   */\n  private advanceToNextStage(output: string, structuredOutput?: StructuredValue): NextStep {\n    const nextStage = this.state.currentStage + 1;\n\n    if (output === '') {\n      this.state.status = 'COMPLETED';\n      this.state.currentStructuredInput = structuredOutput ?? this.state.baseStructuredInput;\n      this.recordEvent({ type: 'PIPELINE_COMPLETE', output: '' });\n      return { type: 'COMPLETE', output: '' };\n    }\n\n    if (nextStage >= this.totalStages) {\n      this.state.status = 'COMPLETED';\n      this.state.currentStructuredInput = structuredOutput ?? this.state.baseStructuredInput;\n      this.recordEvent({ type: 'PIPELINE_COMPLETE', output });\n      return { type: 'COMPLETE', output };\n    }\n\n    this.state.currentStage = nextStage;\n    this.state.currentInput = output;\n    this.state.currentStructuredInput = structuredOutput ?? this.state.baseStructuredInput;\n    this.recordEvent({\n      type: 'STAGE_START',\n      stage: nextStage,\n      input: output,\n      structuredInput: structuredOutput ?? this.state.baseStructuredInput,\n      contextId: this.state.activeRetryContext?.id\n    });\n\n    return {\n      type: 'EXECUTE_STAGE',\n      stage: nextStage,\n      input: output,\n      structuredInput: structuredOutput ?? this.state.baseStructuredInput,\n      context: this.buildStageContext(nextStage)\n    };\n  }\n}\n\nfunction cloneStructuredValue<T>(value: StructuredValue<T>): StructuredValue<T> {\n  const clone = wrapStructured(value);\n  inheritExpressionProvenance(clone, value);\n  return clone;\n}\n","/**\n * Convert JSON data to SCREAMING_SNAKE_CASE XML format\n * Compatible with llmxml's style\n */\n\n/**\n * Convert a string to SCREAMING_SNAKE_CASE\n */\nfunction toScreamingSnakeCase(str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1_$2') // camelCase to snake_case\n    .replace(/[\\s\\-\\.]+/g, '_') // spaces, hyphens, dots to underscores\n    .replace(/[^A-Z0-9_]/gi, '') // remove non-alphanumeric except underscores\n    .toUpperCase()\n    .replace(/^_+|_+$/g, ''); // trim underscores\n}\n\n/**\n * Escape XML special characters\n */\nfunction escapeXml(str: string): string {\n  return str\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;')\n    .replace(/'/g, '&apos;');\n}\n\n/**\n * Convert JSON to XML string\n */\nexport function jsonToXml(data: unknown, rootTag?: string): string {\n  const lines: string[] = [];\n  \n  function convertValue(value: unknown, tagName: string, indent: string = ''): void {\n    if (value === null || value === undefined) {\n      // Skip null/undefined values\n      return;\n    }\n    \n    const tag = toScreamingSnakeCase(tagName);\n    \n    if (Array.isArray(value)) {\n      // For arrays, create a container and items\n      lines.push(`${indent}<${tag}>`);\n      value.forEach((item, index) => {\n        convertValue(item, `item`, indent + '  ');\n      });\n      lines.push(`${indent}</${tag}>`);\n    } else if (typeof value === 'object' && value !== null) {\n      // For objects, create nested tags\n      const entries = Object.entries(value);\n      if (entries.length === 0) {\n        // Empty object\n        lines.push(`${indent}<${tag} />`);\n      } else if (rootTag && indent === '') {\n        // Root level object without wrapper\n        entries.forEach(([key, val]) => {\n          convertValue(val, key, indent);\n        });\n      } else {\n        // Nested object with wrapper\n        lines.push(`${indent}<${tag}>`);\n        entries.forEach(([key, val]) => {\n          convertValue(val, key, indent + '  ');\n        });\n        lines.push(`${indent}</${tag}>`);\n      }\n    } else {\n      // Primitive values\n      const content = escapeXml(String(value));\n      lines.push(`${indent}<${tag}>${content}</${tag}>`);\n    }\n  }\n  \n  // Handle root level\n  if (Array.isArray(data)) {\n    convertValue(data, rootTag || 'ROOT');\n  } else if (typeof data === 'object' && data !== null) {\n    // For root objects, output properties directly without wrapper\n    // This matches the expected test output: <NAME>Alice</NAME><AGE>30</AGE>\n    Object.entries(data).forEach(([key, value]) => {\n      convertValue(value, key, '');\n    });\n  } else {\n    // Primitive at root\n    return `<DOCUMENT>${escapeXml(String(data))}</DOCUMENT>`;\n  }\n  \n  return lines.join('\\n');\n}","import { MlldInterpreterError } from '@core/errors';\nimport { jsonToXml } from './json-to-xml';\nimport { wrapStructured, type StructuredValue, type StructuredValueType } from './structured-value';\n\nfunction parseCsv(text: string): any[][] {\n  const lines = text.trim().split('\\n');\n  return lines.map(line => {\n    const result: string[] = [];\n    let current = '';\n    let inQuotes = false;\n\n    for (let i = 0; i < line.length; i++) {\n      const char = line[i];\n      if (char === '\"') {\n        if (inQuotes && line[i + 1] === '\"') {\n          current += '\"';\n          i++;\n        } else {\n          inQuotes = !inQuotes;\n        }\n        continue;\n      }\n      if (char === ',' && !inQuotes) {\n        result.push(current);\n        current = '';\n        continue;\n      }\n      current += char;\n    }\n\n    if (current || line.endsWith(',')) {\n      result.push(current);\n    }\n\n    return result;\n  });\n}\n\nfunction parseXml(text: string): unknown {\n  try {\n    const parsed = JSON.parse(text);\n    return jsonToXml(parsed);\n  } catch {\n    return `<DOCUMENT>\\n${text}\\n</DOCUMENT>`;\n  }\n}\n\nfunction wrapWithMetadata<T>(\n  value: StructuredValue<T>,\n  extra: Record<string, unknown>\n): StructuredValue<T> {\n  for (const [key, data] of Object.entries(extra)) {\n    Object.defineProperty(value, key, {\n      value: data,\n      enumerable: false,\n      configurable: true\n    });\n  }\n  return value;\n}\n\nexport function buildPipelineStructuredValue(\n  text: string,\n  format: StructuredValueType = 'json'\n): StructuredValue {\n  const normalizedFormat = (format ?? 'json').toLowerCase();\n\n  if (normalizedFormat === 'csv') {\n    try {\n      const data = parseCsv(text);\n      return wrapWithMetadata(wrapStructured(data, 'array', text), { csv: data });\n    } catch (error) {\n      throw new MlldInterpreterError(\n        `Failed to parse CSV: ${error instanceof Error ? error.message : String(error)}`\n      );\n    }\n  }\n\n  if (normalizedFormat === 'xml') {\n    try {\n      const data = parseXml(text);\n      return wrapWithMetadata(wrapStructured(data, 'xml', text), { xml: data });\n    } catch (error) {\n      throw new MlldInterpreterError(\n        `Failed to parse XML: ${error instanceof Error ? error.message : String(error)}`\n      );\n    }\n  }\n\n  if (normalizedFormat === 'text') {\n    return wrapStructured(text, 'text', text);\n  }\n\n  try {\n    const trimmed = typeof text === 'string' ? text.trim() : text;\n    if (trimmed === '') {\n      return wrapStructured('', 'text', text);\n    }\n    const parsed = JSON.parse(text);\n    const structuredType =\n      Array.isArray(parsed) ? 'array' : parsed !== null && typeof parsed === 'object' ? 'object' : typeof parsed;\n    return wrapStructured(parsed, 'json', text, {\n      format: 'json',\n      structuredType\n    });\n  } catch (error) {\n    throw new MlldInterpreterError(\n      `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`\n    );\n  }\n}\n","/**\n * Simplified Context Builder for Pipeline Execution\n * \n * Creates execution environments and pipeline context variables\n * for the simplified retry architecture.\n */\n\nimport type { Environment } from '../../env/Environment';\nimport type { PipelineStageEntry, VariableSource } from '@core/types';\nimport type { StageContext, PipelineEvent } from './state-machine';\nimport type { GuardHistoryEntry, PipelineContextSnapshot } from '../../env/ContextManager';\nimport { createPipelineInputVariable, createSimpleTextVariable, createObjectVariable, createStructuredValueVariable } from '@core/types/variable';\nimport { buildPipelineStructuredValue } from '../../utils/pipeline-input';\nimport { wrapStructured, isStructuredValue, type StructuredValue, type StructuredValueType } from '../../utils/structured-value';\nimport { inheritExpressionProvenance } from '../../utils/expression-provenance';\n\n/**\n * Simplified pipeline context interface\n */\n/**\n * User-facing pipeline context available as @pipeline/@p in stage environments.\n * WHY: Provide stage number, history, and convenience indexing for stage outputs.\n * GOTCHA: 'try' and 'tries' are local to the active retry context and reset downstream.\n */\nexport interface StageOutputAccessor {\n  getStageOutput(stageIndex: number, fallbackText: string): StructuredValue;\n}\n\nexport interface SimplifiedPipelineContext {\n  try: number;                    // Current attempt number\n  tries: string[];                // Previous attempts in current context\n  stage: number;                  // Current stage (1-indexed)\n  [index: number]: string | StructuredValue;        // Array access to pipeline outputs\n  length: number;                 // Number of previous outputs\n  retries?: {                     // Global retry accumulator\n    all: Array<Array<string | StructuredValue>>;              // All attempts from all contexts\n  };\n  guards?: ReadonlyArray<GuardHistoryEntry>;\n}\n\n/**\n * Create execution environment for a pipeline stage (simplified version)\n */\n/**\n * Create execution environment for a pipeline stage.\n * WHY: Constructs @input (with format), @pipeline/@p, and seeds the ambient @mx data.\n * CONTEXT: Hides the synthetic source stage from user-visible indices and stage numbers.\n */\ninterface StageEnvironmentOptions {\n  capturePipelineContext?(context: PipelineContextSnapshot): void;\n  skipSetPipelineContext?: boolean;\n  sourceRetryable?: boolean;\n}\n\nexport async function createStageEnvironment(\n  command: PipelineStageEntry,\n  input: string,\n  structuredInput: StructuredValue,\n  context: StageContext,\n  env: Environment,\n  format?: string,\n  events?: ReadonlyArray<PipelineEvent>,\n  hasSyntheticSource: boolean = false,\n  allRetryHistory?: Map<string, StructuredValue[]>,\n  structuredAccess?: StageOutputAccessor,\n  options?: StageEnvironmentOptions\n): Promise<Environment> {\n  // Adjust stage number for synthetic source (hide from user)\n  const rawId = (command as any)?.rawIdentifier || 'inline-stage';\n  const userVisibleStage = hasSyntheticSource && rawId !== '__source__'\n    ? context.stage - 1\n    : context.stage;\n    \n  const userVisibleTotalStages = hasSyntheticSource \n    ? context.totalStages - 1 \n    : context.totalStages;\n    \n  // Normalize hint value: ensure strings are plain strings and objects are plain objects\n  let normalizedHint: any = context.currentHint;\n  try {\n    if (normalizedHint && typeof normalizedHint === 'object') {\n      // Case 1: Template wrapper → interpolate to string\n      if ('wrapperType' in normalizedHint && Array.isArray((normalizedHint as any).content)) {\n        const { interpolate } = await import('../../core/interpreter');\n        normalizedHint = await interpolate((normalizedHint as any).content, env);\n      }\n      // Case 2: AST/Variable → extract raw value\n      else if ('type' in normalizedHint) {\n        const { extractVariableValue } = await import('../../utils/variable-resolution');\n        normalizedHint = await extractVariableValue(normalizedHint as any, env);\n      }\n\n      // If it's still an object, only keep it if it's a plain object\n      if (normalizedHint && typeof normalizedHint === 'object') {\n        const isPlain = Object.prototype.toString.call(normalizedHint) === '[object Object]'\n          && !('wrapperType' in (normalizedHint as any))\n          && !('type' in (normalizedHint as any))\n          && !('nodeId' in (normalizedHint as any));\n        if (!isPlain) {\n          // Best-effort stringify to avoid leaking wrappers\n          try {\n            const { JSONFormatter } = await import('../../core/json-formatter');\n            normalizedHint = JSONFormatter.stringify(normalizedHint);\n          } catch {\n            normalizedHint = String(normalizedHint);\n          }\n        }\n      }\n    }\n    // Non-object, non-string → coerce to string\n    if (normalizedHint !== undefined && normalizedHint !== null && typeof normalizedHint !== 'string' && typeof normalizedHint !== 'object') {\n      normalizedHint = String(normalizedHint);\n    }\n  } catch {\n    // Best-effort; keep original on failure\n  }\n\n  const pipelineContextSnapshot: PipelineContextSnapshot = {\n    stage: userVisibleStage,\n    totalStages: userVisibleTotalStages,\n    currentCommand: rawId,\n    input: context.currentStructuredInput ?? structuredInput ?? input,\n    previousOutputs: context.previousStructuredOutputs && context.previousStructuredOutputs.length > 0\n      ? context.previousStructuredOutputs\n      : context.previousOutputs,\n    format: format,\n    // Use context-local attempt for ambient @mx.try\n    attemptCount: context.contextAttempt,\n    // Preserve attempts history for @mx.tries\n    attemptHistory: context.historyStructured && context.historyStructured.length > 0\n      ? context.historyStructured\n      : context.history,\n    // Provide hint info for ambient @mx.hint\n    hint: normalizedHint,\n    hintHistory: context.hintHistory || [],\n    sourceRetryable: options?.sourceRetryable ?? false,\n    guards: env.getPipelineGuardHistory()\n  };\n\n  options?.capturePipelineContext?.(pipelineContextSnapshot);\n\n  if (!options?.skipSetPipelineContext) {\n    env.setPipelineContext(pipelineContextSnapshot);\n  }\n\n  // Create child environment\n  const stageEnv = env.createChild();\n  \n  // Set @input variable\n  const pipelineInputWrapper = wrapStructured(structuredInput);\n  inheritExpressionProvenance(pipelineInputWrapper, structuredInput);\n  await setSimplifiedInputVariable(stageEnv, input, pipelineInputWrapper, format);\n  \n  // Set @pipeline / @p variable\n  setSimplifiedPipelineVariable(\n    stageEnv, \n    context, \n    events, \n    hasSyntheticSource,\n    allRetryHistory,\n    structuredAccess\n  );\n  \n  return stageEnv;\n}\n\n/**\n * Set the @input variable (same as original)\n */\nasync function setSimplifiedInputVariable(\n  env: Environment,\n  input: string,\n  structuredInput?: StructuredValue,\n  format?: string\n): Promise<void> {\n  const inputSource: VariableSource = {\n    directive: 'var',\n    syntax: 'template',\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n\n  let inputVar;\n\n  if (format) {\n    const pipelineInputObj = buildPipelineStructuredValue(input, format as StructuredValueType);\n    \n    inputVar = createPipelineInputVariable(\n      'input',\n      pipelineInputObj,\n      format as 'json' | 'csv' | 'xml' | 'text',\n      input,\n      inputSource,\n      1\n    );\n    inputVar.internal = {\n      ...(inputVar.internal ?? {}),\n      isSystem: true,\n      isPipelineParameter: true\n    };\n  } else if (structuredInput && isStructuredValue(structuredInput)) {\n    const structuredVar = createStructuredValueVariable(\n      'input',\n      structuredInput,\n      inputSource,\n      {\n        mx: {},\n        internal: { isSystem: true, isPipelineParameter: true }\n      }\n    );\n    env.setParameterVariable('input', structuredVar);\n    return;\n  } else {\n    // Simple text variable\n    inputVar = createSimpleTextVariable(\n      'input',\n      input,\n      inputSource,\n      {\n        mx: {},\n        internal: { isSystem: true, isPipelineParameter: true }\n      }\n    );\n  }\n\n  env.setParameterVariable('input', inputVar);\n}\n\n/**\n * Set the @pipeline/@p variable (simplified version)\n */\nfunction setSimplifiedPipelineVariable(\n  env: Environment,\n  context: StageContext,\n  events?: ReadonlyArray<PipelineEvent>,\n  hasSyntheticSource: boolean = false,\n  allRetryHistory?: Map<string, StructuredValue[]>,\n  structuredAccess?: StageOutputAccessor\n): void {\n  const pipelineContext = createSimplifiedPipelineContext(\n    context,\n    events,\n    hasSyntheticSource,\n    allRetryHistory,\n    structuredAccess,\n    () => env.getPipelineGuardHistory()\n  );\n  \n  const inputSource: VariableSource = {\n    directive: 'var',\n    syntax: 'template',\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n\n  // Use proper factory to create variable\n  const pipelineVar = createObjectVariable(\n    'pipeline',\n    pipelineContext,\n    false,\n    inputSource,\n    {\n      mx: {},\n      internal: { isSystem: true, isPipelineContext: true }\n    }\n  );\n  \n  env.setParameterVariable('pipeline', pipelineVar);\n  env.setParameterVariable('p', pipelineVar); // Alias\n}\n\n/**\n * Create simplified pipeline context object\n */\nfunction createSimplifiedPipelineContext(\n  context: StageContext,\n  events?: ReadonlyArray<PipelineEvent>,\n  hasSyntheticSource: boolean = false,\n  allRetryHistory?: Map<string, StructuredValue[]>,\n  structuredAccess?: StageOutputAccessor,\n  guardHistoryProvider?: () => ReadonlyArray<GuardHistoryEntry>\n): SimplifiedPipelineContext {\n  const userVisibleStage = hasSyntheticSource && context.stage > 0 \n    ? context.stage - 1 \n    : context.stage;\n\n  if (process.env.MLLD_DEBUG === 'true') {\n    console.error('[SimplifiedContextBuilder] Creating context:', {\n      internalStage: context.stage,\n      userVisibleStage,\n      contextAttempt: context.contextAttempt,\n      historyLength: context.history.length,\n      hasSyntheticSource\n    });\n  }\n\n  const toStructured = (stageIndex: number | null, fallback: string): StructuredValue => {\n    if (stageIndex !== null && structuredAccess) {\n      return structuredAccess.getStageOutput(stageIndex, fallback ?? '');\n    }\n    return buildPipelineStructuredValue(fallback ?? '', 'text');\n  };\n\n  const baseInput = context.outputs?.[0] ?? '';\n  const baseWrapper = toStructured(-1, baseInput);\n\n  const stageWrappers = context.previousOutputs.map((output, index) =>\n    toStructured(index, output)\n  );\n\n  const userVisibleWrappers = hasSyntheticSource && stageWrappers.length > 0\n    ? stageWrappers.slice(1)\n    : stageWrappers;\n\n  const pipelineContext: any = {\n    try: context.contextAttempt,\n    stage: userVisibleStage,\n    length: userVisibleWrappers.length\n  };\n\n  let triesText: unknown = [];\n  let structuredTries: unknown = [];\n  if (context.historyStructured && context.historyStructured.length > 0) {\n    structuredTries = context.historyStructured.map(cloneStructuredValue);\n    triesText = (structuredTries as StructuredValue[]).map(entry => entry.text);\n  } else if (context.history.length > 0) {\n    triesText = [...context.history];\n    structuredTries = context.history.map(entry => toStructured(null, entry));\n  } else if (allRetryHistory && allRetryHistory.size > 0) {\n    const attempts = Array.from(allRetryHistory.values()).map(history =>\n      history.map(attempt => cloneStructuredValue(attempt))\n    );\n    structuredTries = attempts;\n    triesText = attempts.map(history => history.map(item => item.text));\n  }\n\n  pipelineContext.tries = triesText;\n  Object.defineProperty(pipelineContext, 'structuredTries', {\n    value: structuredTries,\n    enumerable: false\n  });\n  pipelineContext[0] = baseWrapper;\n  if (hasSyntheticSource) {\n    userVisibleWrappers.forEach((wrapper, index) => {\n      pipelineContext[index + 1] = wrapper;\n    });\n  } else {\n    stageWrappers.forEach((wrapper, index) => {\n      pipelineContext[index + 1] = wrapper;\n    });\n  }\n\n  Object.defineProperty(pipelineContext, -1, {\n    get: () => userVisibleWrappers[userVisibleWrappers.length - 1],\n    enumerable: false\n  });\n\n  Object.defineProperty(pipelineContext, -2, {\n    get: () => userVisibleWrappers[userVisibleWrappers.length - 2],\n    enumerable: false\n  });\n\n  for (let i = 3; i <= Math.max(10, userVisibleWrappers.length); i++) {\n    Object.defineProperty(pipelineContext, -i, {\n      get: () => userVisibleWrappers[userVisibleWrappers.length - i],\n      enumerable: false\n    });\n  }\n\n  Object.defineProperty(pipelineContext, 'retries', {\n    get: () => {\n      if (!allRetryHistory || allRetryHistory.size === 0) {\n        return { all: [] };\n      }\n      const allAttempts: Array<Array<StructuredValue>> = [];\n      for (const attempts of allRetryHistory.values()) {\n        if (attempts.length > 0) {\n          const mapped = attempts.map(attempt => cloneStructuredValue(attempt));\n          allAttempts.push(mapped);\n        }\n      }\n      return { all: allAttempts };\n    },\n    enumerable: false,\n    configurable: true\n  });\n\n  Object.defineProperty(pipelineContext, 'guards', {\n    get: () => (guardHistoryProvider ? guardHistoryProvider() : []),\n    enumerable: true,\n    configurable: true\n  });\n\n  return pipelineContext as SimplifiedPipelineContext;\n}\n\nfunction cloneStructuredValue<T>(value: StructuredValue<T>): StructuredValue<T> {\n  const clone = wrapStructured(value);\n  inheritExpressionProvenance(clone, value);\n  return clone;\n}\n","/**\n * Shared helpers for output-style directives.\n */\nexport function formatJSONL(value: unknown): string {\n  return JSON.stringify(value);\n}\n","import type { DirectiveNode, SourceLocation } from '@core/types';\nimport type { OutputTargetFile } from '@core/types/output';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult, EvaluationContext } from '../core/interpreter';\nimport { interpolate } from '../core/interpreter';\nimport { evaluateOutputSource } from './output';\nimport { materializeDisplayValue } from '../utils/display-materialization';\nimport { formatJSONL } from './output-shared';\nimport { MlldDirectiveError } from '@core/errors';\nimport * as path from 'path';\nimport type { SecurityDescriptor } from '@core/types/security';\n\ninterface AppendOptions {\n  location?: SourceLocation;\n  directiveKind?: string;\n  format?: string;\n}\n\n/**\n * Evaluate the /append directive.\n * Appends the evaluated source to a file target.\n */\nexport async function evaluateAppend(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<EvalResult> {\n  if (env.getIsImporting()) {\n    return { value: null, env };\n  }\n\n  if (!directive.meta?.hasSource) {\n    throw new MlldDirectiveError(\n      '/append requires source content before the target',\n      'append',\n      { location: directive.location }\n    );\n  }\n\n  const sourceType = directive.meta?.sourceType;\n  if (!sourceType) {\n    throw new MlldDirectiveError(\n      'Unable to determine append source type',\n      'append',\n      { location: directive.location }\n    );\n  }\n\n  const target = directive.values?.target as OutputTargetFile | undefined;\n  if (!target || target.type !== 'file') {\n    throw new MlldDirectiveError(\n      '/append supports file targets only',\n      'append',\n      { location: directive.location }\n    );\n  }\n\n  const sourceResult = await evaluateOutputSource(directive, env, sourceType, context);\n  let content = sourceResult.text;\n  const descriptorSource = sourceResult.rawValue;\n  const materialized = materializeDisplayValue(\n    descriptorSource ?? content,\n    undefined,\n    descriptorSource ?? content,\n    content\n  );\n  content = materialized.text;\n  if (materialized.descriptor) {\n    env.recordSecurityDescriptor(materialized.descriptor);\n  }\n  const format = typeof directive.meta?.format === 'string' ? directive.meta?.format : undefined;\n  await appendContentToFile(target, content, env, {\n    location: directive.location,\n    directiveKind: 'append',\n    format\n  });\n\n  (env as any).hasExplicitOutput = true;\n  return { value: '', env };\n}\n\nexport async function appendContentToFile(\n  target: OutputTargetFile,\n  content: string,\n  env: Environment,\n  options: AppendOptions\n): Promise<void> {\n  const resolvedPath = await resolveAppendPath(target, env);\n  const directiveKind = options.directiveKind ?? 'append';\n  const { payload, format } = formatAppendPayload(resolvedPath, content, {\n    location: options.location,\n    directiveKind,\n    format: options.format\n  });\n\n  const fileSystem = (env as any).fileSystem;\n  if (!fileSystem || typeof fileSystem.appendFile !== 'function') {\n    throw new MlldDirectiveError(\n      'File system not available for append directive',\n      directiveKind,\n      { location: options.location }\n    );\n  }\n\n  await fileSystem.appendFile(resolvedPath, payload);\n\n  env.emitEffect('file', payload, {\n    path: resolvedPath,\n    source: options.location,\n    mode: 'append',\n    metadata: { format }\n  });\n}\n\nasync function resolveAppendPath(\n  target: OutputTargetFile,\n  env: Environment\n): Promise<string> {\n  const descriptors: SecurityDescriptor[] = [];\n  const interpolated = await interpolate(target.path, env, undefined, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  const merged =\n    descriptors.length === 1\n      ? descriptors[0]\n      : descriptors.length > 1\n        ? env.mergeSecurityDescriptors(...descriptors)\n        : undefined;\n  if (merged) {\n    env.recordSecurityDescriptor(merged);\n  }\n  let resolvedPath = String(interpolated);\n\n  if (!resolvedPath) {\n    throw new MlldDirectiveError(\n      'Append target path cannot be empty',\n      'append'\n    );\n  }\n\n  if (resolvedPath.startsWith('@base/')) {\n    const projectRoot = env.getProjectRoot();\n    resolvedPath = path.join(projectRoot, resolvedPath.substring(6));\n  } else if (resolvedPath.startsWith('@root/')) {\n    const projectRoot = env.getProjectRoot();\n    resolvedPath = path.join(projectRoot, resolvedPath.substring(6));\n  }\n\n  if (!path.isAbsolute(resolvedPath)) {\n    resolvedPath = path.resolve(env.getBasePath(), resolvedPath);\n  }\n\n  return resolvedPath;\n}\n\nfunction formatAppendPayload(\n  resolvedPath: string,\n  rawContent: string,\n  options: AppendOptions\n): { payload: string; format: 'jsonl' | 'text' } {\n  const directiveKind = options.directiveKind ?? 'append';\n  const extension = path.extname(resolvedPath).toLowerCase();\n  const explicitFormat = options.format ? String(options.format).toLowerCase() : undefined;\n\n  if (extension === '.json') {\n    throw new MlldDirectiveError(\n      'Cannot append to .json files. Use a .jsonl extension for JSON lines output.',\n      directiveKind,\n      { location: options.location }\n    );\n  }\n\n  if (explicitFormat && explicitFormat !== 'jsonl' && explicitFormat !== 'text') {\n    throw new MlldDirectiveError(\n      `Unsupported /append format \"${explicitFormat}\". Allowed formats: jsonl, text.`,\n      directiveKind,\n      { location: options.location }\n    );\n  }\n\n  const treatAsJsonl = explicitFormat === 'jsonl' || extension === '.jsonl';\n\n  if (treatAsJsonl) {\n    if (extension !== '.jsonl') {\n      throw new MlldDirectiveError(\n        'JSONL format requires a .jsonl file extension.',\n        directiveKind,\n        { location: options.location }\n      );\n    }\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(rawContent);\n    } catch (error) {\n      throw new MlldDirectiveError(\n        'Content appended to .jsonl must be valid JSON. Provide a variable or template that resolves to JSON data.',\n        directiveKind,\n        { location: options.location, cause: error instanceof Error ? error : undefined }\n      );\n    }\n    const formatted = formatJSONL(parsed);\n    return { payload: ensureTrailingNewline(formatted), format: 'jsonl' };\n  }\n\n  return { payload: ensureTrailingNewline(rawContent), format: 'text' };\n}\n\nfunction ensureTrailingNewline(value: string): string {\n  return value.endsWith('\\n') ? value : `${value}\\n`;\n}\n","import type { Environment } from '../../env/Environment';\nimport type { PipelineCommand } from '@core/types';\nimport { appendContentToFile } from '../append';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { materializeDisplayValue } from '../../utils/display-materialization';\nimport { asText } from '../../utils/structured-value';\nimport type { OperationContext } from '../../env/ContextManager';\nimport { materializeGuardInputs } from '../../utils/guard-inputs';\nimport { getGuardTransformedInputs, handleGuardDecision } from '../../hooks/hook-decision-handler';\nimport type { EffectHookNode } from '@core/types/hooks';\nimport type { Variable } from '@core/types/variable';\nimport { extractVariableValue, isVariable } from '../../utils/variable-resolution';\nimport { GuardError, type GuardErrorDetails } from '@core/errors/GuardError';\nimport { isGuardRetrySignal } from '@core/errors/GuardRetrySignal';\nimport type { EvalResult } from '../../core/interpreter';\n\n// Minimal builtin effects support for pipelines. These are inline effects that\n// do not create stages and run after the owning stage succeeds.\n\nconst BUILTIN_EFFECTS = new Set<string>([\n  'log', 'LOG',\n  'output', 'OUTPUT',\n  'show', 'SHOW',\n  'append', 'APPEND'\n]);\n\nexport function isBuiltinEffect(name: string): boolean {\n  return BUILTIN_EFFECTS.has(name);\n}\n\nexport function getBuiltinEffects(): string[] {\n  return Array.from(new Set(Array.from(BUILTIN_EFFECTS).map(n => n.toLowerCase()))).sort();\n}\n\nfunction recordInterpolatedDescriptors(env: Environment, descriptors: SecurityDescriptor[]): void {\n  if (descriptors.length === 0) {\n    return;\n  }\n  const merged =\n    descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n  env.recordSecurityDescriptor(merged);\n}\n\n// Evaluate a single effect argument into a string using the stage environment\nasync function evaluateEffectArg(arg: any, env: Environment): Promise<string> {\n  // UnifiedArgumentList items can be Text nodes, VariableReference, nested exec, objects, arrays, etc.\n  // We reuse interpolate for a best-effort string evaluation.\n  const { interpolate } = await import('../../core/interpreter');\n  if (Array.isArray(arg)) {\n    const descriptors: SecurityDescriptor[] = [];\n    const value = await interpolate(arg, env, undefined, {\n      collectSecurityDescriptor: descriptor => {\n        if (descriptor) {\n          descriptors.push(descriptor);\n        }\n      }\n    });\n    recordInterpolatedDescriptors(env, descriptors);\n    return String(value);\n  }\n  const descriptors: SecurityDescriptor[] = [];\n  const value = await interpolate([arg], env, undefined, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  recordInterpolatedDescriptors(env, descriptors);\n  return String(value);\n}\n\nfunction buildEffectOperationContext(effect: PipelineCommand): OperationContext {\n  const type = typeof effect.rawIdentifier === 'string' ? effect.rawIdentifier.toLowerCase() : 'effect';\n  const hasExplicitSource = Boolean(effect.meta?.hasExplicitSource);\n  const labels = Array.isArray((effect.meta as any)?.securityLabels)\n    ? ((effect.meta as any).securityLabels as string[])\n    : undefined;\n\n  return {\n    type,\n    subtype: 'effect',\n    name: effect.rawIdentifier,\n    labels,\n    location: (effect as any)?.location ?? (effect.meta as any)?.location ?? null,\n    metadata: {\n      trace: `effect:${effect.rawIdentifier ?? type}`,\n      isEffect: true,\n      hasExplicitSource\n    }\n  };\n}\n\nfunction createEffectHookNode(effect: PipelineCommand): EffectHookNode {\n  return {\n    ...effect,\n    type: 'Effect',\n    location: (effect as any)?.location ?? (effect.meta as any)?.location ?? null\n  };\n}\n\nasync function resolveEffectPayload(\n  effect: PipelineCommand,\n  stageOutput: unknown,\n  env: Environment\n): Promise<unknown> {\n  const name = typeof effect.rawIdentifier === 'string' ? effect.rawIdentifier.toLowerCase() : '';\n  const args = effect.args ?? [];\n  const hasExplicitSource = Boolean(effect.meta?.hasExplicitSource);\n  const usesExplicitSource = args.length >= 2;\n  const stageValue = stageOutput ?? '';\n  const stageText = typeof stageValue === 'string' ? stageValue : asText(stageValue);\n\n  switch (name) {\n    case 'log':\n    case 'show': {\n      if (args.length > 0) {\n        const parts: string[] = [];\n        for (const a of args) {\n          parts.push(await evaluateEffectArg(a, env));\n        }\n        return parts.join(' ');\n      }\n      return stageValue ?? stageText;\n    }\n    case 'output': {\n      if (usesExplicitSource && args.length >= 1) {\n        try {\n          return await evaluateEffectArg(args[0], env);\n        } catch {\n          return stageValue ?? stageText;\n        }\n      }\n      return stageValue ?? stageText;\n    }\n    case 'append': {\n      if (hasExplicitSource && args.length > 0) {\n        return await evaluateEffectArg(args[0], env);\n      }\n      return stageValue ?? stageText;\n    }\n    default:\n      return stageValue ?? stageText;\n  }\n}\n\nasync function extractEffectGuardInputs(\n  effect: PipelineCommand,\n  stageOutput: unknown,\n  env: Environment\n): Promise<{ guardInputs: Variable[]; payload: unknown }> {\n  const payload = await resolveEffectPayload(effect, stageOutput, env);\n  const guardInputs = materializeGuardInputs([payload], { nameHint: '__effect_input__' });\n  return { guardInputs, payload };\n}\n\nfunction convertEffectRetryToDeny(\n  error: GuardError,\n  operationContext: OperationContext,\n  env: Environment\n): GuardError {\n  const details = (error as GuardError).details as GuardErrorDetails | undefined;\n  const retryHint =\n    (details?.retryHint ?? null) ?? ((error as any).retryHint === undefined ? null : (error as any).retryHint);\n  const reason =\n    retryHint && typeof retryHint === 'string'\n      ? `Guard retry not supported for effects: ${retryHint}`\n      : 'Guard retry not supported for effects';\n\n  return new GuardError({\n    decision: 'deny',\n    guardName: details?.guardName ?? null,\n    guardFilter: details?.guardFilter,\n    scope: details?.scope,\n    operation: details?.operation ?? operationContext,\n    inputPreview: details?.inputPreview,\n    retryHint,\n    reason,\n    guardContext: details?.guardContext,\n    guardInput: (details as any)?.guardInput ?? null,\n    reasons: details?.reasons,\n    guardResults: details?.guardResults,\n    hints: details?.hints,\n    timing: (details as any)?.timing,\n    sourceLocation: error.sourceLocation ?? operationContext.location ?? undefined,\n    env\n  });\n}\n\n// Execute a builtin effect. Returns void; throws on error to abort the pipeline.\nexport async function runBuiltinEffect(\n  effect: PipelineCommand,\n  stageOutput: unknown,\n  env: Environment\n): Promise<void> {\n  const hookManager = env.getHookManager();\n  const operationContext = buildEffectOperationContext(effect);\n  const hookNode = createEffectHookNode(effect);\n\n  const { guardInputs, payload } = await extractEffectGuardInputs(effect, stageOutput, env);\n  const inputs =\n    guardInputs.length > 0\n      ? guardInputs\n      : materializeGuardInputs([stageOutput ?? ''], { nameHint: '__effect_input__' });\n\n  await env.withOpContext(operationContext, async () => {\n    const preDecision = await hookManager.runPre(hookNode, inputs, env, operationContext);\n    const transformedInputs = getGuardTransformedInputs(preDecision, inputs);\n    const resolvedInputs = transformedInputs ?? inputs;\n\n    try {\n      await handleGuardDecision(preDecision, hookNode, env, operationContext);\n    } catch (error) {\n      if (isGuardRetrySignal(error)) {\n        throw convertEffectRetryToDeny(error as GuardError, operationContext, env);\n      }\n      throw error;\n    }\n\n    const primaryInput = resolvedInputs[0] ?? inputs[0];\n    const payloadVariable = isVariable(primaryInput) ? primaryInput : undefined;\n    const payloadValue =\n      payloadVariable !== undefined ? await extractVariableValue(payloadVariable, env) : payload;\n\n    const effectResult = await executeEffect(effect, payloadValue, payloadVariable, env);\n\n    try {\n      await hookManager.runPost(hookNode, effectResult, resolvedInputs, env, operationContext);\n    } catch (error) {\n      if (isGuardRetrySignal(error)) {\n        throw convertEffectRetryToDeny(error as GuardError, operationContext, env);\n      }\n      throw error;\n    }\n  });\n}\n\nasync function executeEffect(\n  effect: PipelineCommand,\n  payloadValue: unknown,\n  payloadVariable: Variable | undefined,\n  env: Environment\n): Promise<EvalResult> {\n  const name = effect.rawIdentifier;\n  const normalizedPayload = payloadValue ?? '';\n  const payloadText = typeof normalizedPayload === 'string' ? normalizedPayload : asText(normalizedPayload);\n  const descriptorSource = payloadVariable ?? normalizedPayload;\n\n  switch (name) {\n    case 'log':\n    case 'LOG': {\n      const materialized = materializeDisplayValue(\n        descriptorSource ?? payloadText,\n        undefined,\n        descriptorSource ?? payloadText,\n        payloadText\n      );\n      let output = materialized.text;\n      if (!output.endsWith('\\n')) output += '\\n';\n      if (materialized.descriptor) {\n        env.recordSecurityDescriptor(materialized.descriptor);\n      }\n      env.emitEffect('stderr', output);\n      return { value: payloadVariable ?? normalizedPayload, env };\n    }\n\n    case 'show':\n    case 'SHOW': {\n      const materialized = materializeDisplayValue(\n        descriptorSource ?? payloadText,\n        undefined,\n        descriptorSource ?? payloadText,\n        payloadText\n      );\n      let output = materialized.text;\n      if (!output.endsWith('\\n')) output += '\\n';\n      if (materialized.descriptor) {\n        env.recordSecurityDescriptor(materialized.descriptor);\n      }\n      env.emitEffect('both', output);\n      return { value: payloadVariable ?? normalizedPayload, env };\n    }\n\n    case 'output':\n    case 'OUTPUT': {\n      const args = effect.args ?? [];\n      let content = payloadText;\n      let target: any = null;\n      if (args.length > 1) {\n        target = args[1];\n      } else if (args.length === 1) {\n        target = args[0];\n      }\n      if (!target || typeof target !== 'object' || !target.type) {\n        throw new Error('output requires a valid target (file|stream|env|resolver)');\n      }\n\n      const materializedContent = materializeDisplayValue(\n        descriptorSource ?? content,\n        undefined,\n        descriptorSource ?? content,\n        content\n      );\n      content = materializedContent.text;\n      if (materializedContent.descriptor) {\n        env.recordSecurityDescriptor(materializedContent.descriptor);\n      }\n\n      switch (String(target.type)) {\n        case 'file': {\n          const { interpolate } = await import('../../core/interpreter');\n          const path = await import('path');\n          let resolvedPath = '';\n          if (Array.isArray(target.path)) {\n            const descriptors: SecurityDescriptor[] = [];\n            resolvedPath = await interpolate(target.path, env, undefined, {\n              collectSecurityDescriptor: descriptor => {\n                if (descriptor) {\n                  descriptors.push(descriptor);\n                }\n              }\n            });\n            recordInterpolatedDescriptors(env, descriptors);\n          } else if (typeof target.path === 'string') {\n            resolvedPath = target.path;\n          } else if (target.values) {\n            const descriptors: SecurityDescriptor[] = [];\n            resolvedPath = await interpolate(target.values, env, undefined, {\n              collectSecurityDescriptor: descriptor => {\n                if (descriptor) {\n                  descriptors.push(descriptor);\n                }\n              }\n            });\n            recordInterpolatedDescriptors(env, descriptors);\n          }\n          if (!resolvedPath) {\n            throw new Error('output file target requires a non-empty path');\n          }\n\n          if (resolvedPath.startsWith('@base/')) {\n            const projectRoot = (env as any).getProjectRoot ? (env as any).getProjectRoot() : '/';\n            resolvedPath = path.join(projectRoot, resolvedPath.substring(6));\n          } else if (resolvedPath.startsWith('@root/')) {\n            const projectRoot = (env as any).getProjectRoot ? (env as any).getProjectRoot() : '/';\n            resolvedPath = path.join(projectRoot, resolvedPath.substring(6));\n          }\n\n          if (!path.isAbsolute(resolvedPath)) {\n            const base = (env as any).getBasePath ? (env as any).getBasePath() : '/';\n            resolvedPath = path.resolve(base, resolvedPath);\n          }\n\n          if (process.env.MLLD_DEBUG === 'true') {\n            // eslint-disable-next-line no-console\n            console.error('[builtin-effects] output:file →', resolvedPath);\n          }\n          const fileSystem = (env as any).fileSystem;\n          if (!fileSystem || typeof fileSystem.writeFile !== 'function') {\n            throw new Error('File system not available for pipeline output');\n          }\n          const dir = path.dirname(resolvedPath);\n          try {\n            await fileSystem.mkdir(dir, { recursive: true });\n          } catch {\n            // Directory may already exist; ignore\n          }\n          await fileSystem.writeFile(resolvedPath, content);\n\n          env.emitEffect('file', content, { path: resolvedPath });\n          return { value: payloadVariable ?? materializedContent.text, env };\n        }\n        case 'stream': {\n          const stream = target.stream === 'stderr' ? 'stderr' : 'stdout';\n          const payload = content.endsWith('\\n') ? content : content + '\\n';\n          env.emitEffect(stream, payload);\n          return { value: payloadVariable ?? materializedContent.text, env };\n        }\n        case 'env': {\n          let varName = 'MLLD_OUTPUT';\n          if (target.varname) {\n            varName = target.varname;\n          } else {\n            const src = effect.args && effect.args.length > 0 ? effect.args[0] : null;\n            const id = (src && typeof src === 'object' && Array.isArray((src as any).identifier) && (src as any).identifier[0]?.identifier)\n              ? (src as any).identifier[0].identifier\n              : undefined;\n            if (id) varName = `MLLD_${String(id).toUpperCase()}`;\n          }\n          process.env[varName] = content;\n          return { value: payloadVariable ?? materializedContent.text, env };\n        }\n        case 'resolver': {\n          throw new Error('resolver targets not supported yet in pipeline output');\n        }\n        default:\n          throw new Error(`Unknown output target type: ${String(target.type)}`);\n      }\n    }\n\n    case 'append':\n    case 'APPEND': {\n      const args = effect.args ?? [];\n      const hasExplicitSource = Boolean(effect.meta?.hasExplicitSource);\n      const targetArgIndex = hasExplicitSource ? 1 : 0;\n      const target = args[targetArgIndex];\n\n      if (!target || typeof target !== 'object' || target.type !== 'file') {\n        throw new Error('append requires a file target');\n      }\n\n      const materializedPayload = materializeDisplayValue(\n        descriptorSource ?? payloadText,\n        undefined,\n        descriptorSource ?? payloadText,\n        payloadText\n      );\n      const finalPayload = materializedPayload.text;\n      if (materializedPayload.descriptor) {\n        env.recordSecurityDescriptor(materializedPayload.descriptor);\n      }\n\n      await appendContentToFile(target, finalPayload, env, { directiveKind: 'append' });\n      return { value: payloadVariable ?? finalPayload, env };\n    }\n\n    default:\n      throw new Error(`Unsupported builtin effect in pipeline: @${name}`);\n  }\n}\n","export class RateLimitRetry {\n  private attempt = 0;\n  constructor(private maxAttempts = 5, private baseDelay = 500) {}\n\n  async wait(): Promise<boolean> {\n    if (this.attempt >= this.maxAttempts) return false;\n    const delay = this.baseDelay * 2 ** this.attempt;\n    this.attempt++;\n    await new Promise(res => setTimeout(res, delay));\n    return true;\n  }\n\n  reset(): void {\n    this.attempt = 0;\n  }\n}\n\nexport function isRateLimitError(err: any): boolean {\n  if (!err) return false;\n  const msg = typeof err === 'string' ? err : err.message || '';\n  return /rate limit/i.test(msg) || err.status === 429;\n}\n","export function getParallelLimit(): number {\n  const raw = process.env.MLLD_PARALLEL_LIMIT;\n  const n = raw !== undefined ? parseInt(String(raw), 10) : NaN;\n  if (!Number.isFinite(n) || n < 1) return 4;\n  return n;\n}\n\nexport interface ParallelOptions {\n  ordered?: boolean;\n  paceMs?: number; // minimum delay between task starts\n}\n\n/**\n * Run a set of async tasks with a concurrency cap.\n * - ordered=true: results are placed at original indices\n * - ordered=false: results are appended in completion order\n * - paceMs: optional minimum delay between task starts\n */\nexport async function runWithConcurrency<T, R>(\n  items: readonly T[],\n  limit: number,\n  run: (item: T, index: number) => Promise<R>,\n  opts: ParallelOptions = {}\n): Promise<R[]> {\n  const count = items.length;\n  if (count === 0) return [];\n  const cap = Math.max(1, Math.min(limit || 1, count));\n  const ordered = opts.ordered !== false; // default true\n  const paceMs = opts.paceMs && opts.paceMs > 0 ? opts.paceMs : 0;\n\n  const results: R[] = ordered ? new Array(count) : [];\n  let index = 0;\n  let pacingChain: Promise<void> = Promise.resolve();\n\n  const nextIndex = async (): Promise<number> => {\n    // Optional simple pacing control: ensure at least paceMs between starts\n    if (paceMs > 0) {\n      const prev = pacingChain;\n      let release!: () => void;\n      pacingChain = new Promise<void>(res => { release = res; });\n      await prev; // serialize starts\n      setTimeout(release, paceMs);\n    }\n    if (index >= count) return -1;\n    return index++;\n  };\n\n  const worker = async () => {\n    while (true) {\n      const i = await nextIndex();\n      if (i < 0) break;\n      const item = items[i];\n      const r = await run(item, i);\n      if (ordered) {\n        (results as R[])[i] = r;\n      } else {\n        (results as R[]).push(r);\n      }\n    }\n  };\n\n  const workers = Array.from({ length: cap }, () => worker());\n  await Promise.all(workers);\n  return results;\n}\n","import type { SecurityDescriptor } from '@core/types/security';\nimport { mergeDescriptors } from '@core/types/security';\n\nexport interface EvaluatorResult<T = unknown> {\n  value: T;\n  descriptor?: SecurityDescriptor;\n}\n\nexport function createEvaluatorResult<T>(\n  value: T,\n  descriptor?: SecurityDescriptor\n): EvaluatorResult<T> {\n  return descriptor ? { value, descriptor } : { value };\n}\n\nexport function mergeEvaluatorDescriptors(\n  ...results: Array<EvaluatorResult | undefined>\n): SecurityDescriptor | undefined {\n  const descriptors = results\n    .map(result => result?.descriptor)\n    .filter((descriptor): descriptor is SecurityDescriptor => Boolean(descriptor));\n  if (descriptors.length === 0) {\n    return undefined;\n  }\n  return mergeDescriptors(...descriptors);\n}\n\nexport function unwrapEvaluatorResult<T>(result: EvaluatorResult<T>): T {\n  return result.value;\n}\n","import type { Environment } from '../../env/Environment';\nimport { PipelineExecutor } from '../pipeline/executor';\nimport type { PipelineCommand, PipelineStage, PipelineStageEntry } from '@core/types/run';\nimport { extractSecurityDescriptor } from '../../utils/structured-value';\nimport type { SecurityDescriptor } from '@core/types/security';\n\ninterface ParallelExecResult {\n  value: any;\n  descriptor?: SecurityDescriptor;\n}\n\nfunction toPipelineCommand(node: any): PipelineStageEntry {\n  const commandRef = node.commandRef || {};\n  const identifier = Array.isArray(commandRef.identifier)\n    ? commandRef.identifier\n    : commandRef.identifier\n      ? [commandRef.identifier]\n      : [];\n  const rawIdentifier =\n    commandRef.name ||\n    (Array.isArray(commandRef.identifier)\n      ? commandRef.identifier.map((id: any) => id.identifier || id.content || '').find(Boolean)\n      : commandRef.identifier) ||\n    'unknown';\n  const rawArgs = (commandRef.args || []).map((arg: any) => {\n    if (arg && typeof arg === 'object' && 'content' in arg) return (arg as any).content;\n    return typeof arg === 'string' ? arg : '';\n  });\n\n  const command: PipelineCommand & { stream?: boolean } = {\n    identifier,\n    args: commandRef.args || [],\n    fields: commandRef.fields || [],\n    rawIdentifier,\n    rawArgs,\n    meta: {}\n  };\n\n  if (node.withClause) {\n    command.withClause = node.withClause;\n    command.meta = { ...(command.meta || {}), withClause: node.withClause };\n    if (node.withClause.stream !== undefined) {\n      command.stream = node.withClause.stream;\n    }\n  }\n\n  return command;\n}\n\n/**\n * Execute two ExecInvocations in parallel using pipeline semantics.\n * Returns the aggregated result (array string/StructuredValue) plus any descriptor.\n */\nexport async function executeParallelExecInvocations(\n  left: any,\n  right: any,\n  env: Environment\n): Promise<ParallelExecResult> {\n  const stage = [toPipelineCommand(left), toPipelineCommand(right)] as PipelineStage;\n  const pipeline: PipelineStage[] = [stage];\n\n  const executor = new PipelineExecutor(pipeline, env);\n  const executionResult = await executor.execute('', { returnStructured: true });\n  const descriptor = extractSecurityDescriptor(executionResult, {\n    recursive: true,\n    mergeArrayElements: true\n  });\n\n  return { value: executionResult, descriptor };\n}\n","import type { Environment } from '../env/Environment';\nimport { evaluate } from '../core/interpreter';\nimport { MlldDirectiveError } from '../../core/errors/MlldDirectiveError';\nimport { isEqual, toNumber, isTruthy } from './expression';\nimport {\n  createEvaluatorResult,\n  mergeEvaluatorDescriptors,\n  type EvaluatorResult\n} from '../utils/evaluator-result';\nimport { executeParallelExecInvocations } from './helpers/parallel-exec';\n\n/**\n * Unified expression evaluator for all expression types from the unified grammar\n * Handles: BinaryExpression, UnaryExpression, TernaryExpression, ArrayFilterExpression, ArraySliceExpression, Literal nodes\n */\nexport async function evaluateUnifiedExpression(\n  node: any,\n  env: Environment\n): Promise<EvaluatorResult> {\n  try {\n    switch (node.type) {\n      case 'BinaryExpression':\n        return await evaluateBinaryExpression(node, env);\n      case 'UnaryExpression':\n        return await evaluateUnaryExpression(node, env);\n      case 'TernaryExpression':\n        return await evaluateTernaryExpression(node, env);\n      case 'ArrayFilterExpression':\n        return await evaluateArrayFilterExpression(node, env);\n      case 'ArraySliceExpression':\n        return await evaluateArraySliceExpression(node, env);\n      case 'Literal':\n        // Handle none literal (only valid in when context)\n        if (node.valueType === 'none') {\n          throw new Error('The \"none\" keyword can only be used as a condition in /when directives');\n        }\n        return createEvaluatorResult(node.value);\n      case 'VariableReference':\n        // Delegate variable references to the standard evaluator\n        try {\n          const varResult = await evaluate(node, env);\n          return createEvaluatorResult(varResult.value);\n        } catch (error) {\n          // Handle undefined variables gracefully for backward compatibility\n          if (error instanceof Error && error.message.includes('Variable not found')) {\n            return createEvaluatorResult(undefined);\n          }\n          throw error;\n        }\n      case 'ExecReference':\n        // Delegate exec references to the standard evaluator\n        const execResult = await evaluate(node, env);\n        return createEvaluatorResult(execResult.value);\n      case 'Text':\n        // Handle text nodes that might appear in expressions\n        return createEvaluatorResult(node.content);\n      default:\n        // For all other node types, delegate to the standard evaluator\n        const result = await evaluate(node, env);\n        return createEvaluatorResult(result.value);\n    }\n  } catch (error) {\n    throw new MlldDirectiveError(\n      `Expression evaluation failed: ${error instanceof Error ? error.message : String(error)}`,\n      'expression',\n      {\n        location: (node as any)?.location,\n        cause: error as Error,\n        context: { nodeType: (node as any)?.type, operator: (node as any)?.operator },\n        env\n      }\n    );\n  }\n}\n\n/**\n * Evaluate binary expressions (&&, ||, ==, !=, <, >, <=, >=, ~=)\n */\nasync function evaluateBinaryExpression(\n  node: any,\n  env: Environment\n): Promise<EvaluatorResult> {\n  let { operator } = node;\n  \n  // Handle operator being an array (from PEG.js negative lookahead)\n  if (Array.isArray(operator)) {\n    operator = operator[0];\n  }\n  \n  const isExecParallel =\n    operator === '||' &&\n    node.left?.type === 'ExecInvocation' &&\n    node.right?.type === 'ExecInvocation';\n  if (isExecParallel) {\n    const { value, descriptor } = await executeParallelExecInvocations(node.left, node.right, env);\n    return createEvaluatorResult(value, descriptor);\n  }\n  \n  const leftResult = await evaluateUnifiedExpression(node.left, env);\n  const leftValue = leftResult.value;\n  \n  // Short-circuit evaluation for logical operators  \n  if (operator === '&&') {\n    const leftTruthy = isTruthy(leftValue);\n    if (!leftTruthy) {\n      // Short-circuit: if left is falsy, return left value\n      return leftResult;\n    }\n    // Otherwise evaluate and return right\n    const rightResult = await evaluateUnifiedExpression(node.right, env);\n    return rightResult;\n  }\n  \n  if (operator === '||') {\n    const leftTruthy = isTruthy(leftValue);\n    if (leftTruthy) {\n      // Short-circuit: if left is truthy, return left value\n      return leftResult;\n    }\n    // Otherwise evaluate and return right\n    const rightResult = await evaluateUnifiedExpression(node.right, env);\n    return rightResult;\n  }\n\n  if (operator === '??') {\n    const isNullish = leftValue === null || leftValue === undefined;\n    if (!isNullish) {\n      return leftResult;\n    }\n    return await evaluateUnifiedExpression(node.right, env);\n  }\n  \n  const rightResult = await evaluateUnifiedExpression(node.right, env);\n  const rightValue = rightResult.value;\n  const mergedDescriptor = mergeEvaluatorDescriptors(leftResult, rightResult);\n  \n  \n  switch (operator) {\n    case '==':\n      const equal = isEqual(leftValue, rightValue);\n      return createEvaluatorResult(equal, mergedDescriptor);\n    case '!=':\n      return createEvaluatorResult(!isEqual(leftValue, rightValue), mergedDescriptor);\n    case '~=':\n      // Regex match operator\n      const regex = new RegExp(String(rightValue));\n      return createEvaluatorResult(regex.test(String(leftValue)), mergedDescriptor);\n    case '<':\n      const leftNum = toNumber(leftValue);\n      const rightNum = toNumber(rightValue);\n      const ltResult = leftNum < rightNum;\n      return createEvaluatorResult(ltResult, mergedDescriptor);\n    case '>':\n      return createEvaluatorResult(toNumber(leftValue) > toNumber(rightValue), mergedDescriptor);\n    case '<=':\n      return createEvaluatorResult(toNumber(leftValue) <= toNumber(rightValue), mergedDescriptor);\n    case '>=':\n      return createEvaluatorResult(toNumber(leftValue) >= toNumber(rightValue), mergedDescriptor);\n    case '+':\n      return createEvaluatorResult(toNumber(leftValue) + toNumber(rightValue), mergedDescriptor);\n    case '-':\n      return createEvaluatorResult(toNumber(leftValue) - toNumber(rightValue), mergedDescriptor);\n    case '*':\n      return createEvaluatorResult(toNumber(leftValue) * toNumber(rightValue), mergedDescriptor);\n    case '/':\n      return createEvaluatorResult(toNumber(leftValue) / toNumber(rightValue), mergedDescriptor);\n    case '%':\n      return createEvaluatorResult(toNumber(leftValue) % toNumber(rightValue), mergedDescriptor);\n    default:\n      throw new Error(`Unknown binary operator: ${operator}`);\n  }\n}\n\n/**\n * Evaluate unary expressions (!, -, +)\n */\nasync function evaluateUnaryExpression(\n  node: any,\n  env: Environment\n): Promise<EvaluatorResult> {\n  const operandResult = await evaluateUnifiedExpression(node.operand, env);\n  const operandValue = operandResult.value;\n  \n  switch (node.operator) {\n    case '!':\n      return createEvaluatorResult(!isTruthy(operandValue), operandResult.descriptor);\n    case '-':\n      return createEvaluatorResult(-toNumber(operandValue), operandResult.descriptor);\n    case '+':\n      return createEvaluatorResult(+toNumber(operandValue), operandResult.descriptor);\n    default:\n      throw new Error(`Unknown unary operator: ${node.operator}`);\n  }\n}\n\n/**\n * Evaluate ternary expressions (condition ? trueBranch : falseBranch)\n */\nasync function evaluateTernaryExpression(\n  node: any,\n  env: Environment\n): Promise<EvaluatorResult> {\n  const conditionResult = await evaluateUnifiedExpression(node.condition, env);\n  const conditionValue = conditionResult.value;\n  \n  return isTruthy(conditionValue)\n    ? await evaluateUnifiedExpression(node.trueBranch, env)\n    : await evaluateUnifiedExpression(node.falseBranch, env);\n}\n\n/**\n * Evaluate array filter expressions: @array[?condition]\n */\nasync function evaluateArrayFilterExpression(\n  node: any,\n  env: Environment\n): Promise<EvaluatorResult<any[]>> {\n  const arrayResult = await evaluateUnifiedExpression(node.array, env);\n  const array = arrayResult.value;\n  \n  if (!Array.isArray(array)) {\n    throw new Error(`Cannot filter non-array value: ${typeof array}`);\n  }\n  \n  const results = [];\n  for (const item of array) {\n    // Create new environment with current item accessible as '$'\n    const itemEnv = env.withVariable('$', item);\n    const passes = await evaluateUnifiedExpression(node.filter, itemEnv);\n    if (passes.value) {\n      results.push(item);\n    }\n  }\n  \n  return createEvaluatorResult(results, arrayResult.descriptor);\n}\n\n/**\n * Evaluate array slice expressions: @array[start:end]\n */\nasync function evaluateArraySliceExpression(\n  node: any,\n  env: Environment\n): Promise<EvaluatorResult<any[]>> {\n  const arrayResult = await evaluateUnifiedExpression(node.array, env);\n  const array = arrayResult.value;\n  \n  if (!Array.isArray(array)) {\n    throw new Error(`Cannot slice non-array value: ${typeof array}`);\n  }\n  \n  const start = node.start || 0;\n  const end = node.end !== undefined ? node.end : array.length;\n  \n  return createEvaluatorResult(array.slice(start, end), arrayResult.descriptor);\n}\n\n/**\n * Check if a node is a unified expression type\n */\nexport function isUnifiedExpressionNode(node: any): boolean {\n  return node && [\n    'BinaryExpression',\n    'UnaryExpression', \n    'TernaryExpression',\n    'ArrayFilterExpression',\n    'ArraySliceExpression',\n    'Literal'\n  ].includes(node.type);\n}\n\n/**\n * Helper function to evaluate array filter expressions\n * This will be expanded when we implement array operations\n */\nexport async function evaluateArrayFilter(array: any[], filter: any, env: Environment): Promise<any[]> {\n  const results = [];\n  for (const item of array) {\n    // Create a new environment with the current item as '$'\n    const itemEnv = env.withVariable('$', item);\n    const passes = await evaluateUnifiedExpression(filter, itemEnv);\n    if (passes.value) results.push(item);\n  }\n  return results;\n}\n","import type { WhilePipelineStage } from '@core/types';\nimport { isContinueLiteral, isDoneLiteral } from '@core/types/control';\nimport type { Environment } from '../env/Environment';\nimport { evaluate } from '../core/interpreter';\nimport { wrapStructured, isStructuredValue, asData, type StructuredValue } from '../utils/structured-value';\nimport { createStructuredValueVariable, type VariableSource } from '@core/types/variable';\nimport { evaluateUnifiedExpression } from './expressions';\n\ninterface WhileContext {\n  iteration: number;\n  limit: number;\n  active: boolean;\n}\n\nexport type WhileProcessorInvoker = (\n  processor: WhilePipelineStage['processor'],\n  state: StructuredValue,\n  env: Environment\n) => Promise<{ value: unknown; env?: Environment }>;\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\nfunction normalizeState(value: unknown): StructuredValue {\n  if (isStructuredValue(value)) {\n    return value;\n  }\n\n  const textValue = typeof value === 'string' ? value : JSON.stringify(value ?? '');\n  const kind: StructuredValue['type'] =\n    Array.isArray(value) ? 'array' : typeof value === 'object' && value !== null ? 'object' : 'text';\n  return wrapStructured(value as any, kind, textValue);\n}\n\nasync function setWhileInputVariable(env: Environment, value: unknown): Promise<void> {\n  const source: VariableSource = {\n    directive: 'var',\n    syntax: 'template',\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n  const wrapped: StructuredValue = isStructuredValue(value)\n    ? value\n    : wrapStructured(\n        value as any,\n        Array.isArray(value) ? 'array' : typeof value === 'object' && value !== null ? 'object' : 'text',\n        typeof value === 'string' ? value : undefined\n      );\n  const inputVar = createStructuredValueVariable('input', wrapped, source, {\n    internal: { isSystem: true, isPipelineParameter: true }\n  });\n  env.setVariable('input', inputVar);\n}\n\nasync function resolveControlValue(\n  result: any,\n  iterEnv: Environment,\n  currentState: StructuredValue\n): Promise<{ kind: 'done' | 'continue'; value: unknown }> {\n  const unwrapped = isStructuredValue(result) ? asData(result) : result;\n  const controlPayload =\n    unwrapped && typeof unwrapped === 'object' && '__whileControl' in (unwrapped as Record<string, unknown>)\n      ? (unwrapped as Record<string, unknown>)\n      : result && typeof result === 'object' && '__whileControl' in (result as Record<string, unknown>)\n        ? (result as Record<string, unknown>)\n        : null;\n\n  if (controlPayload) {\n    const controlKind = controlPayload.__whileControl === 'done' ? 'done' : 'continue';\n    const controlValue = 'value' in controlPayload ? (controlPayload as any).value : undefined;\n    return { kind: controlKind, value: controlValue ?? currentState };\n  }\n\n  if (unwrapped && typeof unwrapped === 'object' && 'valueType' in (unwrapped as Record<string, unknown>)) {\n    if (isDoneLiteral(unwrapped as any)) {\n      const val = (unwrapped as any).value;\n      if (Array.isArray(val)) {\n        const target = val.length === 1 ? val[0] : val;\n        if (target && typeof target === 'object' && 'type' in (target as Record<string, unknown>)) {\n          const evaluated = await evaluateUnifiedExpression(target as any, iterEnv);\n          return { kind: 'done', value: evaluated.value };\n        }\n        const evaluated = await evaluate(val as any, iterEnv, { isExpression: true });\n        return { kind: 'done', value: evaluated.value };\n      }\n      return { kind: 'done', value: val === 'done' ? currentState : val };\n    }\n    if (isContinueLiteral(unwrapped as any)) {\n      const val = (unwrapped as any).value;\n      if (Array.isArray(val)) {\n        const target = val.length === 1 ? val[0] : val;\n        if (target && typeof target === 'object' && 'type' in (target as Record<string, unknown>)) {\n          const evaluated = await evaluateUnifiedExpression(target as any, iterEnv);\n          return { kind: 'continue', value: evaluated.value };\n        }\n        const evaluated = await evaluate(val as any, iterEnv, { isExpression: true });\n        return { kind: 'continue', value: evaluated.value };\n      }\n      return { kind: 'continue', value: val === 'continue' ? currentState : val };\n    }\n    if ((unwrapped as any).valueType === 'retry') {\n      throw new Error(\"Use 'continue' instead of 'retry' in while processors\");\n    }\n  }\n\n  if (unwrapped === 'retry') {\n    throw new Error(\"Use 'continue' instead of 'retry' in while processors\");\n  }\n  if (unwrapped === 'done') {\n    return { kind: 'done', value: currentState };\n  }\n  if (unwrapped === 'continue') {\n    return { kind: 'continue', value: currentState };\n  }\n\n  return { kind: 'continue', value: isStructuredValue(result) ? result : unwrapped };\n}\n\nexport async function evaluateWhileStage(\n  stage: WhilePipelineStage,\n  input: StructuredValue,\n  env: Environment,\n  invokeProcessor?: WhileProcessorInvoker\n): Promise<unknown> {\n  const cap = stage.cap;\n  const rateMs = stage.rateMs ?? null;\n\n  let state: StructuredValue = normalizeState(input);\n\n  for (let iteration = 1; iteration <= cap; iteration++) {\n    const whileCtx: WhileContext = {\n      iteration,\n      limit: cap,\n      active: true\n    };\n\n    const iterEnv = env.createChild();\n    await setWhileInputVariable(iterEnv, state);\n\n    const evalResult = await iterEnv.withExecutionContext('while', whileCtx, async () => {\n      if (invokeProcessor) {\n        return invokeProcessor(stage.processor, state, iterEnv);\n      }\n      return evaluate(stage.processor as any, iterEnv, { isExpression: true });\n    });\n\n    const value =\n      evalResult && typeof evalResult === 'object' && 'env' in (evalResult as Record<string, unknown>)\n        ? (evalResult as any).value\n        : evalResult;\n    const resultEnv =\n      evalResult && typeof evalResult === 'object' && 'env' in (evalResult as Record<string, unknown>)\n        ? (evalResult as any).env || iterEnv\n        : iterEnv;\n\n    const control = await resolveControlValue(value, resultEnv || iterEnv, state);\n\n    if (control.kind === 'done') {\n      return control.value;\n    }\n\n    state = normalizeState(control.value);\n\n    if (rateMs && iteration < cap) {\n      await sleep(rateMs);\n    }\n  }\n\n  throw new Error(\n    `While loop reached cap (${cap}) without 'done'. Consider increasing cap or check termination logic.`\n  );\n}\n","import type { Environment } from '../../env/Environment';\nimport type { PipelineCommand, PipelineStage, PipelineStageEntry, InlineCommandStage, InlineValueStage, WhilePipelineStage } from '@core/types';\nimport type { ExecInvocation, CommandReference } from '@core/types/primitives';\nimport type { OperationContext, PipelineContextSnapshot } from '../../env/ContextManager';\nimport type { StructuredValue } from '../../utils/structured-value';\nimport type { SecurityDescriptor, DataLabel } from '@core/types/security';\nimport { makeSecurityDescriptor, mergeDescriptors } from '@core/types/security';\n\n// Import pipeline implementation\nimport { PipelineStateMachine, type StageContext, type StageResult } from './state-machine';\nimport { createStageEnvironment } from './context-builder';\nimport { GuardError } from '@core/errors/GuardError';\nimport { MlldCommandExecutionError } from '@core/errors';\nimport { runBuiltinEffect, isBuiltinEffect } from './builtin-effects';\nimport { RateLimitRetry, isRateLimitError } from './rate-limit-retry';\nimport { logger } from '@core/utils/logger';\nimport { getParallelLimit, runWithConcurrency } from '@interpreter/utils/parallel';\nimport {\n  asData,\n  isStructuredValue,\n  wrapStructured,\n  extractSecurityDescriptor,\n  applySecurityDescriptorToStructuredValue,\n  type StructuredValueContext\n} from '../../utils/structured-value';\nimport { buildPipelineStructuredValue } from '../../utils/pipeline-input';\nimport { isPipelineInput } from '@core/types/variable/TypeGuards';\nimport { varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\nimport { wrapLoadContentValue } from '../../utils/load-content-structured';\nimport { inheritExpressionProvenance, setExpressionProvenance } from '../../utils/expression-provenance';\nimport type { CommandExecutionHookOptions } from './command-execution';\nimport type { CommandExecutionContext } from '../../env/ErrorUtils';\nimport { InterpolationContext } from '../../core/interpolation-context';\nimport { StreamBus, type StreamEvent } from './stream-bus';\nimport type { StreamingOptions } from './streaming-options';\nimport { StreamingManager } from '@interpreter/streaming/streaming-manager';\nimport { resolveWorkingDirectory } from '../../utils/working-directory';\nimport { evaluateWhileStage } from '../while';\n\ninterface StageExecutionResult {\n  result: StructuredValue | string | { value: 'retry'; hint?: any; from?: number };\n  labelDescriptor?: SecurityDescriptor;\n}\n\nexport interface ExecuteOptions {\n  returnStructured?: boolean;\n  stream?: boolean;\n}\n\nlet pipelineCounter = 0;\n\nfunction createPipelineId(): string {\n  pipelineCounter += 1;\n  return `pipeline-${pipelineCounter}`;\n}\n\ninterface ParallelStageError {\n  index: number;\n  key?: string | number | null;\n  message: string;\n  error: string;\n  value?: unknown;\n}\n\nfunction formatParallelStageError(error: unknown): string {\n  if (error instanceof Error) {\n    let message = error.message;\n    if (message.startsWith('Directive error (')) {\n      const prefixEnd = message.indexOf(': ');\n      if (prefixEnd >= 0) {\n        message = message.slice(prefixEnd + 2);\n      }\n      const lineIndex = message.indexOf(' at line ');\n      if (lineIndex >= 0) {\n        message = message.slice(0, lineIndex);\n      }\n    }\n    return message;\n  }\n  if (typeof error === 'string') return error;\n  try {\n    return JSON.stringify(error);\n  } catch {\n    return String(error);\n  }\n}\n\nfunction resetParallelErrorsContext(env: Environment, errors: ParallelStageError[]): void {\n  const mxManager = env.getContextManager?.();\n  if (!mxManager) return;\n  while (mxManager.popGenericContext('parallel')) {\n    // clear previous parallel context\n  }\n  mxManager.pushGenericContext('parallel', { errors, timestamp: Date.now() });\n  mxManager.setLatestErrors(errors);\n}\n\n/**\n * Pipeline Executor - Handles actual execution using state machine\n */\n/**\n * Pipeline Executor\n * WHY: Drive stage execution using the state machine and construct proper stage environments.\n * CONTEXT: Re-runs inline effects per retry; empty output is treated as early termination.\n */\nexport class PipelineExecutor {\n  private stateMachine: PipelineStateMachine;\n  private env: Environment;\n  private format?: string;\n  private pipeline: PipelineStage[];\n  private isRetryable: boolean;\n  private sourceFunction?: () => Promise<string | StructuredValue>; // Store source function for retries\n  private hasSyntheticSource: boolean;\n  private parallelCap?: number;\n  private delayMs?: number;\n  private sourceExecutedOnce: boolean = false; // Track if source has been executed once\n  private initialInputText: string = ''; // Store initial input for synthetic source\n  private allRetryHistory: Map<string, StructuredValue[]> = new Map();\n  private rateLimiter = new RateLimitRetry();\n  private structuredOutputs: Map<number, StructuredValue> = new Map();\n  private initialOutput?: StructuredValue;\n  private finalOutput?: StructuredValue;\n  private lastStageIndex: number = -1;\n  private readonly debugStructured = process.env.MLLD_DEBUG_STRUCTURED === 'true';\n  private stageHookNodeCounter = 0;\n  private streamingOptions: StreamingOptions;\n  private pipelineId: string = createPipelineId();\n  private bus: StreamBus;\n  private streamingManager: StreamingManager;\n  private streamingEnabled: boolean;\n  private buildCommandExecutionContext(\n    stageIndex: number,\n    stageContext: StageContext,\n    parallelIndex?: number,\n    directiveType?: string,\n    workingDirectory?: string\n  ): CommandExecutionContext {\n    const stageStreaming = this.isStageStreaming(this.pipeline[stageIndex]);\n    return {\n      directiveType: directiveType || 'run',\n      streamingEnabled: this.streamingEnabled && stageStreaming,\n      pipelineId: this.pipelineId,\n      stageIndex,\n      parallelIndex,\n      streamId: stageContext.contextId ?? createPipelineId(),\n      workingDirectory\n    };\n  }\n\n  constructor(\n    pipeline: PipelineStage[],\n    env: Environment,\n    format?: string,\n    isRetryable: boolean = false,\n    sourceFunction?: () => Promise<string | StructuredValue>,\n    hasSyntheticSource: boolean = false,\n    parallelCap?: number,\n    delayMs?: number,\n    streamingManager?: StreamingManager\n  ) {\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.error('[PipelineExecutor] Constructor:', {\n        pipelineLength: pipeline.length,\n        pipelineStages: pipeline.map(p => Array.isArray(p) ? '[parallel]' : p.rawIdentifier || 'unknown'),\n        isRetryable,\n        hasSourceFunction: !!sourceFunction,\n        hasSyntheticSource\n      });\n    }\n    \n    // Use simplified state machine\n    this.stateMachine = new PipelineStateMachine(\n      pipeline.length,\n      isRetryable,\n      Boolean(sourceFunction)\n    );\n    this.pipeline = pipeline;\n    this.env = env;\n    this.format = format;\n    this.isRetryable = isRetryable;\n    this.sourceFunction = sourceFunction;\n    this.hasSyntheticSource = hasSyntheticSource;\n    this.parallelCap = parallelCap;\n    this.delayMs = delayMs;\n    this.streamingOptions = env.getStreamingOptions();\n    this.streamingEnabled = this.streamingOptions.enabled !== false && this.pipelineHasStreamingStage(pipeline);\n    this.streamingManager = streamingManager ?? env.getStreamingManager();\n    this.bus = this.streamingManager.getBus();\n    if (this.streamingEnabled && !this.streamingOptions.skipDefaultSinks) {\n      this.streamingManager.configure({\n        env: this.env,\n        streamingEnabled: true,\n        streamingOptions: this.streamingOptions\n      });\n    }\n  }\n\n  private emitStream(event: Omit<StreamEvent, 'timestamp' | 'pipelineId'> & { timestamp?: number; pipelineId?: string }): void {\n    if (!this.streamingEnabled) {\n      return;\n    }\n    this.bus.emit({\n      ...event,\n      pipelineId: event.pipelineId || this.pipelineId,\n      timestamp: event.timestamp ?? Date.now()\n    } as StreamEvent);\n  }\n\n  private isStageStreaming(stage: PipelineStageEntry | PipelineStageEntry[]): boolean {\n    if (Array.isArray(stage)) {\n      return stage.some(st => this.isStageStreaming(st));\n    }\n    const candidate = stage as any;\n    return Boolean(\n      candidate?.stream ||\n      candidate?.withClause?.stream ||\n      candidate?.meta?.withClause?.stream\n    );\n  }\n\n  private pipelineHasStreamingStage(pipeline: PipelineStage[]): boolean {\n    return pipeline.some(stage => this.isStageStreaming(stage));\n  }\n\n  /**\n   * Execute the pipeline\n   */\n  /**\n   * Execute the pipeline until completion or error.\n   * WHY: Convert state-machine steps into actual command execution and effect emission.\n   */\n  async execute(initialInput: string | StructuredValue): Promise<string>;\n  async execute(initialInput: string | StructuredValue, options: { returnStructured: true }): Promise<StructuredValue>;\n  async execute(initialInput: string | StructuredValue, options?: ExecuteOptions): Promise<string | StructuredValue> {\n    this.env.resetPipelineGuardHistory();\n    try {\n      const initialWrapper = isStructuredValue(initialInput)\n        ? cloneStructuredValue(initialInput)\n        : wrapStructured(initialInput, 'text', typeof initialInput === 'string' ? initialInput : safeJSONStringify(initialInput));\n      this.applySourceDescriptor(initialWrapper, initialInput);\n\n      // Store initial input for synthetic source stage\n      this.initialInputText = initialWrapper.text;\n      this.structuredOutputs.clear();\n      this.initialOutput = initialWrapper;\n      this.finalOutput = this.initialOutput;\n      this.lastStageIndex = -1;\n      \n      if (process.env.MLLD_DEBUG === 'true') {\n        console.error('[PipelineExecutor] Pipeline start:', {\n          stages: this.pipeline.map(p => Array.isArray(p) ? '[parallel]' : p.rawIdentifier),\n          hasSyntheticSource: this.hasSyntheticSource,\n          isRetryable: this.isRetryable\n        });\n      }\n      this.emitStream({ type: 'PIPELINE_START', source: 'pipeline' });\n      \n      // Start the pipeline\n      let nextStep = this.stateMachine.transition({\n        type: 'START',\n        input: this.initialInputText,\n        structuredInput: this.initialOutput ? cloneStructuredValue(this.initialOutput) : undefined\n      });\n      let iteration = 0;\n\n      // Process steps until complete\n      while (nextStep.type === 'EXECUTE_STAGE') {\n        iteration++;\n        \n        if (process.env.MLLD_DEBUG === 'true') {\n          console.error(`[PipelineExecutor] Iteration ${iteration}:`, {\n            stage: nextStep.stage,\n            stageId: this.pipeline[nextStep.stage]?.rawIdentifier,\n            contextAttempt: nextStep.context.contextAttempt\n          });\n        }\n\n        // Clear cached outputs for this stage and downstream when retrying to avoid stale inputs\n        this.clearStageOutputsFrom(nextStep.stage);\n        \n        if (process.env.MLLD_DEBUG === 'true') {\n          console.error('[PipelineExecutor] Execute stage:', {\n            stage: nextStep.stage,\n            contextId: nextStep.context.contextId,\n            contextAttempt: nextStep.context.contextAttempt,\n            inputLength: nextStep.input?.length,\n            commandId: this.pipeline[nextStep.stage]?.rawIdentifier\n          });\n        }\n        this.emitStream({\n          type: 'STAGE_START',\n          stageIndex: nextStep.stage,\n          command: this.pipeline[nextStep.stage],\n          contextId: nextStep.context.contextId,\n          attempt: nextStep.context.contextAttempt\n        });\n        const stageStartTime = Date.now();\n        \n        const stageEntry = this.pipeline[nextStep.stage];\n        const result = Array.isArray(stageEntry)\n          ? await this.executeParallelStage(nextStep.stage, stageEntry, nextStep.input, nextStep.context)\n          : await this.executeSingleStage(nextStep.stage, stageEntry, nextStep.input, nextStep.context);\n        \n        if (process.env.MLLD_DEBUG === 'true') {\n          console.error('[PipelineExecutor] Stage result:', {\n            resultType: result.type,\n            isRetry: result.type === 'retry'\n          });\n        }\n        if (result.type === 'success') {\n          const stageEntry = this.pipeline[nextStep.stage];\n          this.emitStream({\n            type: 'STAGE_SUCCESS',\n            stageIndex: nextStep.stage,\n            durationMs: Date.now() - stageStartTime\n          });\n        } else if (result.type === 'error') {\n          this.emitStream({\n            type: 'STAGE_FAILURE',\n            stageIndex: nextStep.stage,\n            error: result.error\n          });\n        }\n        \n        // Let state machine decide next step\n        nextStep = this.stateMachine.transition({ \n          type: 'STAGE_RESULT', \n          result \n        });\n        \n        // Update retry history\n        this.allRetryHistory = this.stateMachine.getAllRetryHistory();\n        \n        if (process.env.MLLD_DEBUG === 'true') {\n          console.error('[PipelineExecutor] Next step:', {\n            type: nextStep.type,\n            nextStage: nextStep.type === 'EXECUTE_STAGE' ? nextStep.stage : undefined\n          });\n        }\n        \n        // Safety check for infinite loops\n        if (iteration > 100) {\n          throw new Error('Pipeline exceeded 100 iterations');\n        }\n      }\n      \n      // Handle final state\n      switch (nextStep.type) {\n        case 'COMPLETE':\n          this.emitStream({ type: 'PIPELINE_COMPLETE' });\n          if (options?.returnStructured) {\n            return this.getFinalOutput();\n          }\n          return nextStep.output;\n        \n        case 'ERROR':\n          this.emitStream({ type: 'PIPELINE_ABORT', reason: nextStep.error.message });\n          throw new MlldCommandExecutionError(\n            `Pipeline failed at stage ${nextStep.stage + 1}: ${nextStep.error.message}`,\n            undefined,\n            {\n              command: this.pipeline[nextStep.stage]?.rawIdentifier || 'unknown',\n              exitCode: 1,\n              duration: 0,\n              workingDirectory: this.env.getExecutionDirectory()\n            }\n          );\n        \n        case 'ABORT':\n          this.emitStream({ type: 'PIPELINE_ABORT', reason: nextStep.reason || 'aborted' });\n          throw new MlldCommandExecutionError(\n            `Pipeline aborted: ${nextStep.reason}`,\n            undefined,\n            {\n              command: 'pipeline',\n              exitCode: 1,\n              duration: 0,\n              workingDirectory: this.env.getExecutionDirectory()\n            }\n          );\n        \n        default:\n          throw new Error('Pipeline ended in unexpected state');\n      }\n    } finally {\n      if (this.streamingEnabled && !this.streamingOptions.skipDefaultSinks) {\n        try {\n          this.streamingManager.teardown();\n        } catch {\n          // ignore teardown errors\n        }\n      }\n    }\n  }\n\n  /**\n   * Execute a single stage\n   */\n  /**\n   * Execute a single pipeline stage with the constructed stage environment.\n   * GOTCHA: Inline effects are run after successful stage execution and re-run on retries.\n   */\n  private async executeSingleStage(\n    stageIndex: number,\n    command: PipelineStageEntry,\n    input: string,\n    context: StageContext\n  ): Promise<StageResult> {\n    let stageEnv: Environment | undefined;\n    let mxManager: ReturnType<Environment['getContextManager']> | undefined;\n    let pipelineSnapshot: PipelineContextSnapshot | undefined;\n    let stageDescriptor: SecurityDescriptor | undefined;\n    let parentPipelineContextPushed = false;\n\n    try {\n      const structuredInput = this.getStageOutput(stageIndex - 1, input);\n      this.logStructuredStage('input', command.rawIdentifier, stageIndex, structuredInput);\n      if (process.env.MLLD_DEBUG === 'true') {\n        try {\n          const prevOut = this.structuredOutputs.get(stageIndex - 1);\n          const currOut = this.structuredOutputs.get(stageIndex);\n          console.error('[PipelineExecutor] Stage input snapshot', {\n            stageIndex,\n            command: command.rawIdentifier,\n            input,\n            structuredInput: this.debugNormalize(structuredInput),\n            previousStageOutput: this.debugNormalize(prevOut),\n            cachedCurrentOutput: this.debugNormalize(currOut)\n          });\n        } catch {}\n      }\n      // Set up execution environment for a single command stage\n      parentPipelineContextPushed = true;\n      stageEnv = await createStageEnvironment(\n        command,\n        input,\n        structuredInput,\n        context,\n        this.env,\n        this.format,\n        this.stateMachine.getEvents(),\n        this.hasSyntheticSource,\n        this.allRetryHistory,\n        {\n          getStageOutput: (stage, fallback) => this.getStageOutput(stage, fallback)\n        },\n        {\n          capturePipelineContext: snapshot => {\n            pipelineSnapshot = snapshot;\n          },\n          skipSetPipelineContext: false,\n          sourceRetryable: this.isRetryable\n        }\n      );\n      if (!pipelineSnapshot) {\n        throw new Error('Pipeline context snapshot unavailable for pipeline stage');\n      }\n      stageDescriptor = this.buildStageDescriptor(command, stageIndex, context, structuredInput);\n      mxManager = stageEnv.getContextManager();\n      const stageOpContext = this.createPipelineOperationContext(command, stageIndex, context);\n\n      const stageHookNode = this.createStageHookNode(command);\n\n      const executeStage = async (): Promise<StageResult> => {\n        let stageExecution: StageExecutionResult | undefined;\n        while (true) {\n          try {\n            if ((command as WhilePipelineStage).type === 'whileStage') {\n              const whileStage = command as WhilePipelineStage;\n              const whileResult = await evaluateWhileStage(\n                whileStage,\n                structuredInput,\n                stageEnv!,\n                async (processor, stateValue, iterEnv) => {\n                  const processorCommand = this.buildWhileProcessorCommand(processor);\n                  const normalizedState = this.normalizeWhileInput(stateValue);\n                  const execution = await this.executeCommand(\n                    processorCommand,\n                    normalizedState.text,\n                    normalizedState.structured,\n                    iterEnv,\n                    stageOpContext,\n                    stageHookNode,\n                    stageIndex,\n                    context\n                  );\n                  return { value: execution.result, env: iterEnv };\n                }\n              );\n              stageExecution = {\n                result: whileResult\n              };\n              this.rateLimiter.reset();\n              break;\n            }\n            if ((command as InlineValueStage).type === 'inlineValue') {\n              stageExecution = await this.executeInlineValueStage(\n                command as InlineValueStage,\n                structuredInput,\n                stageEnv!\n              );\n            } else if ((command as InlineCommandStage).type === 'inlineCommand') {\n              stageExecution = await this.executeInlineCommandStage(\n                command as InlineCommandStage,\n                structuredInput,\n                stageEnv!,\n                stageOpContext,\n                stageHookNode,\n                stageIndex,\n                context\n              );\n            } else {\n              stageExecution = await this.executeCommand(\n                command as PipelineCommand,\n                input,\n                structuredInput,\n                stageEnv!,\n                stageOpContext,\n                stageHookNode,\n                stageIndex,\n                context\n              );\n            }\n            const output = stageExecution.result;\n            this.rateLimiter.reset();\n            break;\n          } catch (err: any) {\n            if (err instanceof GuardError) {\n              if (err.decision === 'retry') {\n                return {\n                  type: 'retry',\n                  reason: err.message,\n                  hint: err.retryHint\n                };\n              }\n              throw err;\n            }\n            if (isRateLimitError(err)) {\n              if (process.env.MLLD_DEBUG === 'true') {\n                logger.warn('Rate limit detected, retrying with backoff');\n              }\n              const retry = await this.rateLimiter.wait();\n              if (retry) continue;\n            }\n            throw err;\n          }\n        }\n\n        if (!stageExecution) {\n          throw new Error('Pipeline command did not produce a result');\n        }\n        const output = stageExecution.result;\n        if (this.isRetrySignal(output)) {\n          if (process.env.MLLD_DEBUG === 'true') {\n            console.error('[PipelineExecutor] Retry detected at stage', context.stage);\n          }\n          const from = this.parseRetryScope(output);\n          const hint = this.parseRetryHint(output);\n          return { type: 'retry', reason: hint || 'Stage requested retry', from, hint } as StageResult;\n        }\n\n        let normalized = this.normalizeOutput(output);\n        if (this.debugStructured) {\n          console.error('[PipelineExecutor][pre-output]', {\n            stage: command.rawIdentifier,\n            stageIndex\n          });\n        }\n        this.logStructuredStage('output', command.rawIdentifier, stageIndex, normalized);\n        if (this.debugStructured) {\n          console.error('[PipelineExecutor][post-output]', {\n            stage: command.rawIdentifier,\n            stageIndex\n          });\n        }\n        normalized = this.finalizeStageOutput(\n          normalized,\n          structuredInput,\n          output,\n          stageDescriptor,\n          stageExecution?.labelDescriptor\n        );\n        if (process.env.MLLD_DEBUG === 'true') {\n          try {\n            console.error('[PipelineExecutor] Stage output snapshot', {\n              stageIndex,\n              command: command.rawIdentifier,\n              normalized: this.debugNormalize(normalized)\n            });\n          } catch {}\n        }\n        if (this.debugStructured) {\n          try {\n            console.error('[PipelineExecutor][finalized-output]', {\n              stage: command.rawIdentifier,\n              stageIndex,\n              labels: normalized?.mx?.labels ?? null,\n              metadataLabels: normalized?.metadata?.security?.labels ?? null\n            });\n          } catch {}\n        }\n        this.structuredOutputs.set(stageIndex, normalized);\n        this.finalOutput = normalized;\n        this.lastStageIndex = stageIndex;\n\n        const normalizedText = normalized.text ?? '';\n        if (!normalizedText || normalizedText.trim() === '') {\n          await this.runInlineEffects(command, normalized, stageEnv!);\n          return { type: 'success', output: normalizedText, structuredOutput: normalized };\n        }\n\n        try {\n          const pmx = this.env.getPipelineContext?.();\n          if (pmx) {\n            this.env.updatePipelineContext({\n              ...pmx,\n              hint: null\n            });\n          }\n        } catch {}\n\n        await this.runInlineEffects(command, normalized, stageEnv!);\n        return { type: 'success', output: normalizedText, structuredOutput: normalized };\n      };\n\n      const runWithinPipeline = async (): Promise<StageResult> => {\n        if (mxManager) {\n          return await mxManager.withOperation(stageOpContext, executeStage);\n        }\n        return await executeStage();\n      };\n\n      return await this.env.withPipeContext(pipelineSnapshot, runWithinPipeline);\n    } catch (error) {\n      return { type: 'error', error: error as Error };\n    } finally {\n      // Ensure the parent environment does not retain the pipeline context after this stage\n      if (parentPipelineContextPushed && this.env.getPipelineContext()) {\n        this.env.clearPipelineContext();\n      }\n    }\n  }\n\n  /**\n   * Execute a pipeline command\n   */\n  /**\n   * Execute a pipeline command (function or synthetic __source__).\n   * CONTEXT: __source__ uses the initial input the first time, and a source function on retries.\n   */\n  private async executeCommand(\n    command: PipelineCommand,\n    input: string,\n    structuredInput: StructuredValue,\n    stageEnv: Environment,\n    operationContext?: OperationContext,\n    hookNode?: ExecInvocation,\n    stageIndex?: number,\n    stageContext?: StageContext,\n    parallelIndex?: number\n  ): Promise<StageExecutionResult> {\n    // Special handling for synthetic __source__ stage\n    if (command.rawIdentifier === '__source__') {\n      const firstTime = !this.sourceExecutedOnce;\n      this.sourceExecutedOnce = true;\n      \n      if (process.env.MLLD_DEBUG === 'true') {\n        console.error('[PipelineExecutor] Executing __source__ stage:', {\n          firstTime,\n          hasSourceFunction: !!this.sourceFunction,\n          isRetryable: this.isRetryable\n        });\n      }\n      \n      if (firstTime) {\n        const sourceOutput = this.initialOutput\n          ? cloneStructuredValue(this.initialOutput)\n          : wrapStructured(this.initialInputText, 'text', this.initialInputText);\n        return { result: sourceOutput };\n      }\n      \n      // Retry execution - need to call source function\n      if (!this.sourceFunction) {\n        throw new Error('Cannot retry stage 0: input is not a function. Make the source a function to enable retries.');\n      }\n      \n      // Re-execute the source function to get fresh input\n      const fresh = await this.sourceFunction();\n      if (process.env.MLLD_DEBUG === 'true') {\n        console.error('[PipelineExecutor] Source function returned fresh input:', fresh);\n      }\n      const freshWrapper = isStructuredValue(fresh)\n        ? cloneStructuredValue(fresh)\n        : wrapStructured(fresh, 'text', typeof fresh === 'string' ? fresh : safeJSONStringify(fresh));\n      this.applySourceDescriptor(freshWrapper, fresh);\n      this.initialOutput = freshWrapper;\n      this.finalOutput = freshWrapper;\n      this.initialInputText = freshWrapper.text;\n      return { result: freshWrapper };\n    }\n\n    // Synthetic identity stage for pipelines that only have inline effects\n    if (command.rawIdentifier === '__identity__') {\n      return { result: input };\n    }\n    \n    // Resolve the command reference\n      const commandVar = await this.resolveCommandReference(command, stageEnv);\n    \n    if (!commandVar) {\n      throw new Error(`Pipeline command ${command.rawIdentifier} not found`);\n    }\n\n    // Get arguments and validate them\n    let args = await this.processArguments(command.args || [], stageEnv);\n\n    // Execute with metadata preservation\n    const { AutoUnwrapManager } = await import('../auto-unwrap-manager');\n\n    // Smart parameter binding for pipeline functions\n    if (args.length === 0) {\n      args = await AutoUnwrapManager.executeWithPreservation(async () => {\n        return await this.bindParametersAutomatically(commandVar, input, structuredInput);\n      });\n    }\n    \n    const result = await AutoUnwrapManager.executeWithPreservation(async () => {\n      return await this.executeCommandVariable(commandVar, args, stageEnv, input, structuredInput, {\n        hookNode,\n        operationContext,\n        stageInputs: [structuredInput],\n        executionContext: stageContext && typeof stageIndex === 'number'\n          ? this.buildCommandExecutionContext(stageIndex, stageContext, parallelIndex, command.rawIdentifier)\n          : undefined\n      });\n    });\n\n    const labelDescriptor = this.buildCommandLabelDescriptor(command, commandVar);\n\n    return { result, labelDescriptor };\n  }\n\n  private async executeInlineCommandStage(\n    stage: InlineCommandStage,\n    structuredInput: StructuredValue,\n    stageEnv: Environment,\n    operationContext: OperationContext | undefined,\n    hookNode: ExecInvocation | undefined,\n    stageIndex: number,\n    stageContext: StageContext,\n    parallelIndex?: number\n  ): Promise<StageExecutionResult> {\n    const mxManager = stageEnv.getContextManager();\n    const runInline = async (): Promise<StageExecutionResult> => {\n      const { interpolate } = await import('../../core/interpreter');\n      const descriptors: SecurityDescriptor[] = [];\n      const workingDirectory = await resolveWorkingDirectory(stage.workingDir as any, stageEnv, {\n        sourceLocation: stage.location,\n        directiveType: 'run'\n      });\n      const commandText = await interpolate(stage.command, stageEnv, InterpolationContext.ShellCommand, {\n        collectSecurityDescriptor: d => {\n          if (d) descriptors.push(d);\n        }\n      });\n      const stdinInput = structuredInput?.text ?? '';\n      const result = await stageEnv.executeCommand(\n        commandText,\n        { input: stdinInput, ...(workingDirectory ? { workingDirectory } : {}) },\n        this.buildCommandExecutionContext(stageIndex, stageContext, parallelIndex, undefined, workingDirectory)\n      );\n      const { processCommandOutput } = await import('@interpreter/utils/json-auto-parser');\n      const normalizedResult = processCommandOutput(result);\n      const labelDescriptor =\n        descriptors.length > 1 ? stageEnv.mergeSecurityDescriptors(...descriptors) : descriptors[0];\n      return { result: normalizedResult, labelDescriptor };\n    };\n    if (mxManager && operationContext) {\n      return await mxManager.withOperation(operationContext, runInline);\n    }\n    return await runInline();\n  }\n\n  private async executeInlineValueStage(\n    stage: InlineValueStage,\n    stageInput: StructuredValue,\n    stageEnv: Environment\n  ): Promise<StageExecutionResult> {\n    const { evaluateDataValue } = await import('../data-value-evaluator');\n    const value = await evaluateDataValue(stage.value, stageEnv);\n    const text = safeJSONStringify(value);\n    const wrapped = wrapStructured(value, 'object', text);\n    const descriptor = extractSecurityDescriptor(value, { recursive: true, mergeArrayElements: true });\n    if (descriptor) {\n      applySecurityDescriptorToStructuredValue(wrapped, descriptor);\n      setExpressionProvenance(wrapped, descriptor);\n    }\n    const mergedDescriptor =\n      descriptor && stageEnv ? stageEnv.mergeSecurityDescriptors(descriptor) : descriptor;\n    return {\n      result: this.finalizeStageOutput(wrapped, stageInput, value, mergedDescriptor),\n      labelDescriptor: mergedDescriptor\n    };\n  }\n\n  private normalizeWhileInput(value: StructuredValue | unknown): { structured: StructuredValue; text: string } {\n    if (isStructuredValue(value)) {\n      const textValue = value.text ?? safeJSONStringify(asData(value));\n      return { structured: value, text: textValue };\n    }\n\n    const textValue = typeof value === 'string' ? value : safeJSONStringify(value);\n    const kind: StructuredValue['type'] =\n      Array.isArray(value) ? 'array' : typeof value === 'object' && value !== null ? 'object' : 'text';\n    const structured = wrapStructured(value as any, kind, textValue);\n    return { structured, text: textValue };\n  }\n\n  private buildWhileProcessorCommand(processor: any): PipelineCommand {\n    if (processor?.type === 'ExecInvocation') {\n      const ref = processor.commandRef || {};\n      const identifier = Array.isArray(ref.identifier)\n        ? ref.identifier\n        : ref.identifier\n          ? [ref.identifier]\n          : [];\n      const rawIdentifier =\n        ref.name ||\n        (Array.isArray(ref.identifier)\n          ? ref.identifier.map((id: any) => id.identifier || id.content || '').find(Boolean)\n          : ref.identifier) ||\n        'while-processor';\n      const rawArgs = (ref.args || []).map((arg: any) => {\n        if (arg && typeof arg === 'object') {\n          if ('content' in arg && typeof (arg as any).content === 'string') {\n            return (arg as any).content;\n          }\n          if ((arg as any).identifier) {\n            return `@${(arg as any).identifier}`;\n          }\n        }\n        return '';\n      });\n      const command: PipelineCommand & { stream?: boolean } = {\n        identifier,\n        args: ref.args || [],\n        fields: ref.fields || [],\n        rawIdentifier,\n        rawArgs,\n        meta: {}\n      };\n      if (processor.withClause && processor.withClause.stream !== undefined) {\n        command.stream = processor.withClause.stream;\n      }\n      return command;\n    }\n\n    if (processor?.type === 'VariableReferenceWithTail') {\n      const variable = (processor as any).variable || processor;\n      const rawIdentifier = variable?.identifier || 'while-processor';\n      return {\n        identifier: variable ? [variable] : [],\n        args: [],\n        fields: variable?.fields || [],\n        rawIdentifier,\n        rawArgs: []\n      };\n    }\n\n    if (processor?.type === 'VariableReference') {\n      return {\n        identifier: [processor],\n        args: [],\n        fields: processor.fields || [],\n        rawIdentifier: processor.identifier || 'while-processor',\n        rawArgs: []\n      };\n    }\n\n    const fallbackId =\n      (processor && typeof processor === 'object' && 'identifier' in processor && (processor as any).identifier) ||\n      (processor && typeof processor === 'object' && 'rawIdentifier' in processor && (processor as any).rawIdentifier) ||\n      'while-processor';\n    return {\n      identifier: [],\n      args: [],\n      fields: [],\n      rawIdentifier: fallbackId as string,\n      rawArgs: []\n    };\n  }\n\n  /**\n   * Process and validate command arguments\n   */\n  private async processArguments(args: any[], env: Environment): Promise<any[]> {\n    const evaluatedArgs: any[] = [];\n\n    for (const arg of args) {\n      // Evaluate the argument\n      if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean' || arg === null) {\n        // Preserve primitives as-is for proper parameter typing downstream\n        evaluatedArgs.push(arg);\n      } else if (arg && typeof arg === 'object') {\n        const evaluatedArg = await this.evaluateArgumentNode(arg, env);\n        evaluatedArgs.push(evaluatedArg);\n      }\n    }\n\n    return evaluatedArgs;\n  }\n\n  private buildCommandLabelDescriptor(\n    command: PipelineCommand,\n    commandVar: any\n  ): SecurityDescriptor | undefined {\n    const descriptors: SecurityDescriptor[] = [];\n    const inlineLabels = (command as any)?.securityLabels as DataLabel[] | undefined;\n    if (inlineLabels && inlineLabels.length > 0) {\n      descriptors.push(makeSecurityDescriptor({ labels: inlineLabels }));\n    }\n    const variableLabels = Array.isArray(commandVar?.mx?.labels) ? (commandVar.mx.labels as DataLabel[]) : undefined;\n    if (variableLabels && variableLabels.length > 0) {\n      descriptors.push(makeSecurityDescriptor({ labels: variableLabels }));\n    }\n    if (descriptors.length === 0) {\n      return undefined;\n    }\n    if (descriptors.length === 1) {\n      return descriptors[0];\n    }\n    return this.env.mergeSecurityDescriptors(...descriptors);\n  }\n\n  /**\n   * Evaluate a single argument node\n   */\n  private async evaluateArgumentNode(arg: any, env: Environment): Promise<any> {\n    if (arg.type === 'VariableReference') {\n      const variable = env.getVariable(arg.identifier);\n      if (!variable) {\n        throw new Error(`Variable not found: ${arg.identifier}`);\n      }\n\n      const { resolveVariable, ResolutionContext } = await import('../../utils/variable-resolution');\n      // Resolve variable in pipeline-input context to preserve wrapper types where appropriate\n      let value = await resolveVariable(variable, env, ResolutionContext.PipelineInput);\n\n      // Apply field access if present\n      if (arg.fields && arg.fields.length > 0) {\n        const { accessFields } = await import('../../utils/field-access');\n        const fieldResult = await accessFields(value, arg.fields, { preserveContext: false, sourceLocation: (arg as any)?.location, env });\n        value = fieldResult;\n      }\n\n      // Return raw value so executables receive correctly typed params (objects/arrays/strings)\n      return value;\n    }\n\n    // For other node types, interpolate\n    const { interpolate } = await import('../../core/interpreter');\n    const value = await interpolate([arg], env);\n    // Try to preserve JSON-like structures\n    try {\n      return JSON.parse(value);\n    } catch {\n      return value;\n    }\n  }\n\n  /**\n   * Smart parameter binding for functions without explicit arguments\n   */\n  private async bindParametersAutomatically(commandVar: any, input: string, structuredInput?: StructuredValue): Promise<any[]> {\n    let paramNames: string[] | undefined;\n\n    if (commandVar && commandVar.type === 'executable' && commandVar.value) {\n      paramNames = commandVar.value.paramNames;\n    } else if (commandVar && commandVar.paramNames) {\n      paramNames = commandVar.paramNames;\n    }\n\n    if (!paramNames || paramNames.length === 0) {\n      return [];\n    }\n\n    // Auto-unwrap LoadContentResult objects\n    const { AutoUnwrapManager } = await import('../auto-unwrap-manager');\n    const unwrappedOutput = AutoUnwrapManager.unwrap(input);\n\n    // Single parameter - pass input directly\n    // Preserve StructuredValue wrapper per DATA.md: \"Pipeline stages must preserve StructuredValue wrappers\"\n    if (paramNames.length === 1) {\n      if (structuredInput && isStructuredValue(structuredInput)) {\n        return [structuredInput];\n      }\n      return [{ type: 'Text', content: unwrappedOutput }];\n    }\n\n    // Multiple parameters - try smart JSON destructuring\n    try {\n      const parsed = JSON.parse(unwrappedOutput);\n      if (typeof parsed === 'object' && !Array.isArray(parsed)) {\n        return paramNames.map(name => ({\n          type: 'Text',\n          content: parsed[name] !== undefined \n            ? (typeof parsed[name] === 'string' ? parsed[name] : JSON.stringify(parsed[name]))\n            : ''\n        }));\n      }\n    } catch {\n      // Not JSON, fall through\n    }\n\n    // Not an object or not JSON, pass as first parameter\n    return [{ type: 'Text', content: unwrappedOutput }];\n  }\n\n  /**\n   * Execute a command variable with arguments\n   */\n  private async executeCommandVariable(\n    commandVar: any,\n    args: any[],\n    env: Environment,\n    stdinInput?: string,\n    structuredInput?: StructuredValue,\n    hookOptions?: CommandExecutionHookOptions\n  ): Promise<string | { value: 'retry'; hint?: any; from?: number }> {\n    const { executeCommandVariable } = await import('./command-execution');\n    return await executeCommandVariable(commandVar, args, env, stdinInput, structuredInput, hookOptions);\n  }\n\n  /**\n   * Resolve a command reference to an executable variable\n   */\n  private async resolveCommandReference(\n    command: PipelineCommand,\n    env: Environment\n  ): Promise<any> {\n    const { resolveCommandReference } = await import('./command-execution');\n    return await resolveCommandReference(command, env);\n  }\n\n  private isRetrySignal(output: any): boolean {\n    let isRetry = false;\n    if (isStructuredValue(output)) {\n      const data = output.data as unknown;\n      isRetry =\n        output.text === 'retry' ||\n        typeof data === 'string' && data === 'retry' ||\n        (data && typeof data === 'object' && (data as any).value === 'retry');\n    } else {\n      isRetry =\n        output === 'retry' ||\n        (output && typeof output === 'object' && (output as any).value === 'retry');\n    }\n    \n    if (process.env.MLLD_DEBUG === 'true') {\n      console.error('[PipelineExecutor] Retry check:', {\n        output,\n        result: isRetry\n      });\n    }\n    \n    return isRetry;\n  }\n\n  private parseRetryScope(output: any): number | undefined {\n    if (output && typeof output === 'object' && typeof output.from === 'number') {\n      return output.from;\n    }\n    return undefined;\n  }\n\n  private parseRetryHint(output: any): any {\n    if (output && typeof output === 'object' && 'hint' in output) {\n      return (output as any).hint;\n    }\n    return undefined;\n  }\n\n  private createPipelineOperationContext(\n    command: PipelineStageEntry,\n    stageIndex: number,\n    stageContext: StageContext\n  ): OperationContext {\n    const labels = (command as any)?.securityLabels as DataLabel[] | undefined;\n    return {\n      type: 'pipeline-stage',\n      subtype: command.rawIdentifier,\n      name: command.rawIdentifier,\n      labels,\n      metadata: {\n        stageIndex: stageIndex + 1,\n        totalStages: stageContext.totalStages,\n        streaming: this.streamingEnabled\n      }\n    };\n  }\n\n  private async executeParallelStage(\n    stageIndex: number,\n    commands: PipelineStageEntry[],\n    input: string,\n    context: StageContext\n  ): Promise<StageResult> {\n    try {\n      const errors: ParallelStageError[] = [];\n      resetParallelErrorsContext(this.env, errors);\n      const sharedStructuredInput = this.getStageOutput(stageIndex - 1, input);\n      const results = await runWithConcurrency(\n        commands,\n        Math.min(this.parallelCap ?? getParallelLimit(), commands.length),\n        async (cmd, parallelIndex) => {\n          const branchInput = cloneStructuredValue(sharedStructuredInput);\n          this.logStructuredStage('input', cmd.rawIdentifier, stageIndex, branchInput, true);\n          let pipelineSnapshot: PipelineContextSnapshot | undefined;\n          const subEnv = await createStageEnvironment(\n            cmd,\n            input,\n            branchInput,\n            context,\n            this.env,\n            this.format,\n            this.stateMachine.getEvents(),\n            this.hasSyntheticSource,\n            this.allRetryHistory,\n            {\n              getStageOutput: (stage, fallback) => this.getStageOutput(stage, fallback)\n            },\n            {\n              capturePipelineContext: snapshot => {\n                pipelineSnapshot = snapshot;\n              },\n              skipSetPipelineContext: false,\n              sourceRetryable: this.isRetryable\n            }\n          );\n\n          if (!pipelineSnapshot) {\n            throw new Error('Pipeline context snapshot unavailable for parallel branch');\n          }\n\n          const branchCtxManager = subEnv.getContextManager();\n          const stageDescriptor = this.buildStageDescriptor(cmd, stageIndex, context, branchInput);\n\n          const branchOpContext = this.createPipelineOperationContext(cmd, stageIndex, context);\n          const branchHookNode = this.createStageHookNode(cmd);\n\n          const executeBranch = async (): Promise<{ normalized: StructuredValue; labels?: SecurityDescriptor } | { value: 'retry'; hint?: any; from?: number }> => {\n            try {\n              const stageExecution =\n                (cmd as InlineValueStage).type === 'inlineValue'\n                  ? await this.executeInlineValueStage(cmd as InlineValueStage, branchInput, subEnv)\n                  : (cmd as InlineCommandStage).type === 'inlineCommand'\n                    ? await this.executeInlineCommandStage(\n                        cmd as InlineCommandStage,\n                        branchInput,\n                        subEnv,\n                        branchOpContext,\n                        branchHookNode,\n                        stageIndex,\n                        context,\n                        parallelIndex\n                      )\n                    : await this.executeCommand(\n                        cmd as PipelineCommand,\n                        input,\n                        branchInput,\n                        subEnv,\n                        branchOpContext,\n                        branchHookNode,\n                        stageIndex,\n                        context,\n                        parallelIndex\n                      );\n              if (this.isRetrySignal(stageExecution.result)) {\n                return stageExecution.result as RetrySignal;\n              }\n              let normalized = this.normalizeOutput(stageExecution.result);\n              this.logStructuredStage('output', cmd.rawIdentifier, stageIndex, normalized, true);\n              normalized = this.finalizeStageOutput(\n                normalized,\n                branchInput,\n                stageExecution.result,\n                stageDescriptor,\n                stageExecution.labelDescriptor\n              );\n              await this.runInlineEffects(cmd, normalized, subEnv);\n              return { normalized, labels: stageExecution.labelDescriptor };\n            } catch (err) {\n              const message = formatParallelStageError(err);\n              const marker: ParallelStageError = {\n                index: parallelIndex,\n                key: parallelIndex,\n                message,\n                error: message,\n                value: extractStageValue(branchInput)\n              };\n              errors.push(marker);\n              const markerText = safeJSONStringify(marker);\n              const normalized = wrapStructured(marker, 'object', markerText);\n              this.logStructuredStage('output', cmd.rawIdentifier, stageIndex, normalized, true);\n              return { normalized };\n            }\n          };\n\n          return await this.env.withPipeContext(pipelineSnapshot, async () => {\n            if (branchCtxManager) {\n              return await branchCtxManager.withOperation(branchOpContext, executeBranch);\n            }\n            return await executeBranch();\n          });\n        },\n        { ordered: true, paceMs: this.delayMs }\n      );\n\n      const retrySignal = results.find(res => this.isRetrySignal(res as any));\n      if (retrySignal) {\n        return { type: 'error', error: new Error('retry not supported in parallel stage') };\n      }\n\n      const branchPayloads = results as Array<{ normalized: StructuredValue; labels?: SecurityDescriptor }>;\n      if (errors.length === 0) {\n        for (let i = 0; i < branchPayloads.length; i++) {\n          const candidate = extractStageValue(branchPayloads[i].normalized);\n          if (candidate && typeof candidate === 'object' && 'message' in (candidate as any) && 'error' in (candidate as any)) {\n            const marker: ParallelStageError = {\n              index: typeof (candidate as any).index === 'number' ? (candidate as any).index : i,\n              key: (candidate as any).key ?? i,\n              message: String((candidate as any).message ?? (candidate as any).error),\n              error: String((candidate as any).error ?? (candidate as any).message),\n              value: (candidate as any).value\n            };\n            errors.push(marker);\n          }\n        }\n      }\n      resetParallelErrorsContext(this.env, errors);\n\n      const aggregatedData = branchPayloads.map(result => extractStageValue(result.normalized));\n      const aggregatedText = safeJSONStringify(aggregatedData);\n      const aggregatedBase = wrapStructured(aggregatedData, 'array', aggregatedText, {\n        stages: branchPayloads.map(result => result.normalized),\n        errors\n      });\n      const stageDescriptors = branchPayloads\n        .map(result => result.labels ?? getStructuredSecurityDescriptor(result.normalized))\n        .filter((descriptor): descriptor is SecurityDescriptor => Boolean(descriptor));\n      const aggregatedDescriptor = stageDescriptors.length > 0\n        ? mergeDescriptors(...stageDescriptors)\n        : undefined;\n      const aggregated = this.finalizeStageOutput(aggregatedBase, sharedStructuredInput, aggregatedData, aggregatedDescriptor);\n      this.structuredOutputs.set(stageIndex, aggregated);\n      this.finalOutput = aggregated;\n      this.lastStageIndex = stageIndex;\n      return { type: 'success', output: aggregated.text, structuredOutput: aggregated };\n    } catch (err) {\n      return { type: 'error', error: err as Error };\n    }\n  }\n\n  private buildStageDescriptor(\n    command: PipelineStageEntry,\n    stageIndex: number,\n    context: StageContext,\n    _structuredInput: StructuredValue\n  ): SecurityDescriptor | undefined {\n    const labels = (command as any)?.securityLabels as DataLabel[] | undefined;\n    if (labels && labels.length > 0) {\n      return makeSecurityDescriptor({ labels });\n    }\n    return undefined;\n  }\n\n  private normalizeOutput(output: any): StructuredValue {\n    this.logStructuredValue('normalize:raw', output);\n    if (isStructuredValue(output)) {\n      this.logStructuredValue('normalize:structured', output);\n      return output;\n    }\n    if (isPipelineInput(output)) {\n      return output;\n    }\n\n    if (output === null || output === undefined) {\n      const wrapped = wrapStructured('', 'text', '');\n      this.logStructuredValue('normalize:wrapped', wrapped);\n      return wrapped;\n    }\n\n    if (typeof output === 'string') {\n      const wrapped = wrapStructured(output, 'text', output);\n      this.logStructuredValue('normalize:wrapped', wrapped);\n      return wrapped;\n    }\n\n    if (typeof output === 'number' || typeof output === 'boolean' || typeof output === 'bigint') {\n      const text = String(output);\n      const wrapped = wrapStructured(output, 'text', text);\n      this.logStructuredValue('normalize:wrapped', wrapped);\n      return wrapped;\n    }\n\n    if (Array.isArray(output)) {\n      const normalizedArray = output.map(item => extractStageValue(item));\n      const text = safeJSONStringify(normalizedArray);\n      const wrapped = wrapStructured(normalizedArray, 'array', text);\n      this.logStructuredValue('normalize:wrapped', wrapped);\n      return wrapped;\n    }\n\n    if (typeof output === 'object') {\n      const maybeText = typeof (output as any).content === 'string' ? (output as any).content : undefined;\n      const text = maybeText ?? safeJSONStringify(output);\n      const wrapped = wrapStructured(output, 'object', text);\n      this.logStructuredValue('normalize:wrapped', wrapped);\n      return wrapped;\n    }\n\n    const wrapped = wrapStructured(output, 'text', safeJSONStringify(output));\n    this.logStructuredValue('normalize:wrapped', wrapped);\n    return wrapped;\n  }\n\n  private finalizeStageOutput(\n    value: StructuredValue,\n    stageInput: StructuredValue,\n    rawOutput: unknown,\n    ...descriptorHints: (SecurityDescriptor | undefined)[]\n  ): StructuredValue {\n    const descriptor = this.mergeStageDescriptors(value, stageInput, rawOutput, descriptorHints);\n    if (descriptor) {\n      applySecurityDescriptorToStructuredValue(value, descriptor);\n      setExpressionProvenance(value, descriptor);\n    }\n    return value;\n  }\n\n  private mergeStageDescriptors(\n    normalizedValue: StructuredValue,\n    stageInput: StructuredValue,\n    rawOutput: unknown,\n    descriptorHints: (SecurityDescriptor | undefined)[] = []\n  ): SecurityDescriptor | undefined {\n    const descriptors: SecurityDescriptor[] = [];\n    const inputDescriptor = extractSecurityDescriptor(stageInput, {\n      recursive: true,\n      mergeArrayElements: true\n    });\n    if (inputDescriptor) {\n      descriptors.push(inputDescriptor);\n    }\n\n    const rawDescriptor = extractSecurityDescriptor(rawOutput ?? normalizedValue, {\n      recursive: true,\n      mergeArrayElements: true\n    });\n    if (rawDescriptor) {\n      descriptors.push(rawDescriptor);\n    }\n\n    const existingDescriptor = getStructuredSecurityDescriptor(normalizedValue);\n    if (existingDescriptor) {\n      descriptors.push(existingDescriptor);\n    }\n\n    for (const hint of descriptorHints) {\n      if (hint) {\n        descriptors.push(hint);\n      }\n    }\n\n    if (process.env.MLLD_DEBUG === 'true') {\n      try {\n        console.error('[PipelineExecutor][mergeStageDescriptors]', {\n          inputLabels: inputDescriptor?.labels ?? null,\n          rawLabels: rawDescriptor?.labels ?? null,\n          existingLabels: existingDescriptor?.labels ?? null,\n          hintLabels: descriptorHints.map(hint => hint?.labels ?? null),\n          normalizedLabels: normalizedValue?.mx?.labels ?? null,\n          normalizedText: normalizedValue?.text\n        });\n      } catch {}\n    }\n\n    if (descriptors.length === 0) {\n      return undefined;\n    }\n\n    if (descriptors.length === 1) {\n      return descriptors[0];\n    }\n\n    return this.env.mergeSecurityDescriptors(...descriptors);\n  }\n\n  private applySourceDescriptor(\n    wrapper: StructuredValue,\n    source: unknown\n  ): void {\n    const descriptor = extractSecurityDescriptor(source, {\n      recursive: true,\n      mergeArrayElements: true\n    });\n    if (!descriptor) {\n      return;\n    }\n    applySecurityDescriptorToStructuredValue(wrapper, descriptor);\n    setExpressionProvenance(wrapper, descriptor);\n  }\n\n  /**\n   * Execute any inline builtin effects attached to the command/stage.\n   * Effects do not count as stages and run after successful execution.\n   */\n  private async runInlineEffects(\n    command: any,\n    stageOutput: StructuredValue | string,\n    stageEnv: Environment\n  ): Promise<void> {\n    if (!command?.effects || !Array.isArray(command.effects) || command.effects.length === 0) return;\n\n    for (const effectCmd of command.effects) {\n      try {\n        if (!effectCmd?.rawIdentifier || !isBuiltinEffect(effectCmd.rawIdentifier)) continue;\n        await runBuiltinEffect(effectCmd, stageOutput, stageEnv);\n      } catch (err) {\n        // Fail-fast on effect errors\n        if (err instanceof Error) {\n          throw new MlldCommandExecutionError(\n            `Inline effect @${effectCmd.rawIdentifier} failed: ${err.message}`,\n            undefined,\n            {\n              command: effectCmd.rawIdentifier,\n              exitCode: 1,\n              duration: 0,\n              workingDirectory: this.env.getExecutionDirectory()\n            }\n          );\n        }\n        throw err;\n      }\n    }\n  }\n\n  private getStageOutput(stageIndex: number, fallbackText: string = ''): StructuredValue {\n    if (stageIndex < 0) {\n      if (!this.initialOutput) {\n        this.initialOutput = wrapStructured(fallbackText, 'text', fallbackText);\n      }\n      return this.initialOutput;\n    }\n\n    const cached = this.structuredOutputs.get(stageIndex);\n    if (cached) {\n      return cached;\n    }\n\n    const wrapper = buildPipelineStructuredValue(fallbackText, 'text');\n    this.structuredOutputs.set(stageIndex, wrapper);\n    return wrapper;\n  }\n\n  private getFinalOutput(): StructuredValue {\n    if (this.finalOutput) {\n      return this.finalOutput;\n    }\n    if (this.lastStageIndex >= 0) {\n      return this.getStageOutput(this.lastStageIndex, this.initialOutput?.text ?? '');\n    }\n    if (this.initialOutput) {\n      return this.initialOutput;\n    }\n    return wrapStructured('', 'text', '');\n  }\n\n  private clearStageOutputsFrom(startStage: number): void {\n    const keys = Array.from(this.structuredOutputs.keys());\n    for (const key of keys) {\n      if (key >= startStage) {\n        this.structuredOutputs.delete(key);\n      }\n    }\n  }\n\n  private createStageHookNode(command: PipelineStageEntry): ExecInvocation {\n    const nodeId = `pipeline-stage-${this.stageHookNodeCounter++}`;\n    const commandRef: CommandReference = {\n      type: 'CommandReference',\n      nodeId: `${nodeId}-command`,\n      identifier: command.rawIdentifier,\n      args: [],\n      fields: (command as any)?.fields\n    };\n    return {\n      type: 'ExecInvocation',\n      nodeId,\n      commandRef,\n      withClause: undefined,\n      location: (command as any)?.location ?? (command as any)?.meta?.location\n    };\n  }\n\n  private logStructuredStage(\n    phase: 'input' | 'output',\n    stageName: string,\n    stageIndex: number,\n    value: StructuredValue,\n    isParallelBranch = false\n  ): void {\n    if (!this.debugStructured) {\n      return;\n    }\n    try {\n      console.error(`[PipelineExecutor][${phase}]`, {\n        stage: stageName,\n        stageIndex,\n        parallel: isParallelBranch,\n        labels: value?.mx?.labels ?? null,\n        taint: value?.mx?.taint ?? null,\n        metadataLabels: value?.metadata?.security?.labels ?? null\n      });\n      console.error('[PipelineExecutor][detail-start]', {\n        phase,\n        stage: stageName\n      });\n      console.error('[PipelineExecutor]', {\n        phase,\n        stage: stageName,\n        stageIndex,\n        parallel: isParallelBranch,\n        type: value?.type,\n        textSnippet: snippet(value?.text),\n        dataPreview: previewValue(value?.data)\n      });\n      console.error('[PipelineExecutor][detail-end]', {\n        phase,\n        stage: stageName\n      });\n    } catch (error) {\n      console.error('[PipelineExecutor][logStructuredStage:error]', {\n        phase,\n        stage: stageName,\n        stageIndex,\n        error: error instanceof Error ? error.message : error\n      });\n    }\n  }\n\n  private debugNormalize(value: any): any {\n    try {\n      if (value === undefined || value === null) return value;\n      if (typeof value === 'string') return value;\n      if (typeof value === 'object') {\n        const base: any = { type: (value as any).type };\n        if ((value as any).text !== undefined) base.text = (value as any).text;\n        if ((value as any).data !== undefined && typeof (value as any).data !== 'object') {\n          base.data = (value as any).data;\n        }\n        if (Array.isArray((value as any).mx?.labels)) {\n          base.labels = (value as any).mx.labels;\n        }\n        return base;\n      }\n      return value;\n    } catch {\n      return '[unserializable]';\n    }\n  }\n\n  private logStructuredValue(label: string, value: unknown): void {\n    if (!this.debugStructured) {\n      return;\n    }\n    try {\n      if (isStructuredValue(value)) {\n        console.error('[PipelineExecutor]', {\n          label,\n          type: value.type,\n          textSnippet: snippet(value.text),\n          dataPreview: previewValue(value.data)\n        });\n      } else {\n        console.error('[PipelineExecutor]', {\n          label,\n          typeofValue: typeof value,\n          preview: previewValue(value)\n        });\n      }\n    } catch (error) {\n      console.error('[PipelineExecutor][logStructuredValue:error]', {\n        label,\n        error: error instanceof Error ? error.message : error\n      });\n    }\n  }\n}\n\nfunction safeJSONStringify(value: unknown): string {\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value ?? '');\n  }\n}\n\nfunction extractStageValue(value: any): any {\n  if (isStructuredValue(value)) {\n    return asData(value);\n  }\n  if (isPipelineInput(value)) {\n    return value.data;\n  }\n  return value;\n}\n\nfunction snippet(text: string | undefined, max: number = 120): string | undefined {\n  if (!text) {\n    return text;\n  }\n  return text.length <= max ? text : `${text.slice(0, max)}…`;\n}\n\nfunction previewValue(value: unknown): unknown {\n  if (value === null || value === undefined) {\n    return value;\n  }\n  if (isStructuredValue(value)) {\n    return {\n      type: value.type,\n      textSnippet: snippet(value.text, 60)\n    };\n  }\n  if (Array.isArray(value)) {\n    return {\n      length: value.length,\n      sample: value.slice(0, 3).map(item => (isStructuredValue(item) ? { type: item.type, text: snippet(item.text, 40) } : item))\n    };\n  }\n  if (typeof value === 'object') {\n    const keys = Object.keys(value as Record<string, unknown>);\n    return {\n      keys: keys.slice(0, 5),\n      size: keys.length\n    };\n  }\n  return value;\n}\n\nfunction getStructuredSecurityDescriptor(value: StructuredValue | undefined): SecurityDescriptor | undefined {\n  if (!value) {\n    return undefined;\n  }\n  if (value.mx) {\n    return varMxToSecurityDescriptor(value.mx as StructuredValueContext);\n  }\n  return undefined;\n}\n\nfunction cloneStructuredValue<T>(value: StructuredValue<T>): StructuredValue<T> {\n  const cloned = wrapStructured(value);\n  inheritExpressionProvenance(cloned, value);\n  return cloned;\n}\n","/**\n * Built-in transformer detection and metadata\n * \n * This module defines which transformers are built into mlld\n * and don't require explicit /exe definitions.\n */\n\n/**\n * List of built-in transformer names\n */\nconst BUILTIN_TRANSFORMERS = new Set([\n  // Format converters\n  'json',\n  'json.loose',\n  'json.strict',\n  'json.llm',\n  'json.fromlist',\n  'JSON',\n  'JSON_LOOSE',\n  'JSON_STRICT',\n  'JSON_LLM',\n  'JSON_FROMLIST',\n  'xml',\n  'XML',\n  'csv',\n  'CSV',\n  'md',\n  'MD',\n\n  // String transformations\n  'upper',\n  'UPPER',\n  'lower',\n  'LOWER',\n  'trim',\n  'TRIM',\n\n  // These might be built-in (need to verify)\n  'pretty',\n  'PRETTY',\n  'sort',\n  'SORT'\n]);\n\n/**\n * Check if a transformer name is a built-in\n */\nexport function isBuiltinTransformer(name: string): boolean {\n  return BUILTIN_TRANSFORMERS.has(name);\n}\n\n/**\n * Get list of all built-in transformers for error messages\n */\nexport function getBuiltinTransformers(): string[] {\n  // Return lowercase versions for display\n  return Array.from(new Set(\n    Array.from(BUILTIN_TRANSFORMERS).map(t => t.toLowerCase())\n  )).sort();\n}\n","import type { PipelineCommand, PipelineStage, PipelineStageEntry } from '@core/types';\nimport { isBuiltinEffect } from './builtin-effects';\n\n/**\n * Attach builtin effects (e.g., @log, @show, @output) to preceding functional stages.\n * - Effects after a parallel group attach to each command in the group.\n * - Leading effects attach to the first functional stage encountered.\n * - If the pipeline contains only effects, synthesize an __identity__ stage to host them.\n */\nexport function attachBuiltinEffects(pipeline: PipelineStage[]): {\n  functionalPipeline: PipelineStage[];\n  hadLeadingEffects: boolean;\n} {\n  const functional: PipelineStage[] = [];\n  const pendingLeadingEffects: PipelineCommand[] = [];\n  let hadLeadingEffects = false;\n\n  for (const stage of pipeline) {\n    if (Array.isArray(stage)) {\n      const { functionalPipeline: group, hadLeadingEffects: inner } = attachBuiltinEffects(stage);\n      if (pendingLeadingEffects.length > 0 && group.length > 0) {\n        for (const cmd of group as PipelineStageEntry[]) {\n          if ((cmd as PipelineCommand).rawIdentifier) {\n            const command = cmd as PipelineCommand;\n            command.effects = [\n              ...(command.effects || []),\n              ...pendingLeadingEffects\n            ];\n          }\n        }\n        pendingLeadingEffects.length = 0;\n      }\n      if (group.length > 0) {\n        functional.push(group as PipelineStage);\n      }\n      hadLeadingEffects = hadLeadingEffects || inner;\n      continue;\n    }\n\n    const name = stage.rawIdentifier;\n    const lowerName = typeof name === 'string' ? name.toLowerCase() : '';\n    const requiresMeta = lowerName === 'append';\n    const isInlineEffect = isBuiltinEffect(name) && (\n      (stage as PipelineCommand).meta?.isBuiltinEffect || !requiresMeta\n    );\n    if (isInlineEffect) {\n      if (functional.length > 0) {\n        const prev = functional[functional.length - 1];\n        if (Array.isArray(prev)) {\n          for (const pcmd of prev as PipelineStageEntry[]) {\n            if ((pcmd as PipelineCommand).rawIdentifier) {\n              const command = pcmd as PipelineCommand;\n              command.effects = [\n                ...(command.effects || []),\n                stage\n              ];\n            }\n          }\n        } else {\n          const prevCmd = prev as PipelineStageEntry;\n          if ((prevCmd as PipelineCommand).rawIdentifier) {\n            (prevCmd as PipelineCommand).effects = [\n              ...(((prevCmd as PipelineCommand).effects) || []),\n              stage\n            ];\n          }\n        }\n      } else {\n        pendingLeadingEffects.push(stage);\n        hadLeadingEffects = true;\n      }\n      continue;\n    }\n\n    const cmd: PipelineStageEntry = { ...(stage as any) };\n    if (pendingLeadingEffects.length > 0) {\n      (cmd as any).effects = [...((cmd as any).effects || []), ...pendingLeadingEffects];\n      pendingLeadingEffects.length = 0;\n    }\n    functional.push(cmd as PipelineStage);\n  }\n\n  if (functional.length === 0 && pendingLeadingEffects.length > 0) {\n    functional.push({\n      rawIdentifier: '__identity__',\n      identifier: [],\n      args: [],\n      fields: [],\n      rawArgs: [],\n      effects: [...pendingLeadingEffects]\n    } as PipelineCommand);\n    pendingLeadingEffects.length = 0;\n  }\n\n  return { functionalPipeline: functional, hadLeadingEffects };\n}\n","/**\n * Unified Pipeline Processor\n * \n * Single entry point for all pipeline processing in the interpreter.\n * Consolidates the various pipeline handling paths into one consistent flow.\n */\n\nimport type { Environment } from '@interpreter/env/Environment';\nimport type { Variable } from '@core/types/variable';\nimport { MlldDirectiveError } from '@core/errors';\nimport { detectPipeline, debugPipelineDetection, type DetectedPipeline } from './detector';\nimport type { PipelineStage, PipelineCommand, WhilePipelineStage } from '@core/types';\nimport { PipelineExecutor } from './executor';\nimport { isBuiltinTransformer, getBuiltinTransformers } from './builtin-transformers';\nimport { logger } from '@core/utils/logger';\nimport { attachBuiltinEffects } from './effects-attachment';\nimport { wrapExecResult } from '../../utils/structured-exec';\nimport {\n  ensureStructuredValue,\n  isStructuredValue,\n  wrapStructured,\n  extractSecurityDescriptor,\n  applySecurityDescriptorToStructuredValue,\n  type StructuredValue,\n  type StructuredValueMetadata\n} from '../../utils/structured-value';\nimport { varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\nimport { inheritExpressionProvenance, setExpressionProvenance } from '../../utils/expression-provenance';\nimport { makeSecurityDescriptor, mergeDescriptors, type SecurityDescriptor, type DataLabel } from '@core/types/security';\nimport { wrapLoadContentValue } from '../../utils/load-content-structured';\nimport { resolveNestedValue } from '../../utils/display-materialization';\n\n/**\n * Context for pipeline processing\n */\n/**\n * Unified pipeline processing input\n * WHY: Provide a single entry that handles detection, validation, and execution across evaluators.\n * CONTEXT: Supports explicit pipeline arrays and auto-detected tails; can mark inputs as retryable.\n */\nexport interface UnifiedPipelineContext {\n  // Required\n  value: any;                    // Initial value (Variable, string, object, etc.)\n  env: Environment;              // Execution environment\n  descriptorHint?: SecurityDescriptor; // Optional descriptor hint when value lost metadata\n  \n  // Optional detection sources\n  node?: any;                    // AST node that might have pipeline\n  directive?: any;               // Directive that might have pipeline\n  \n  // Manual pipeline (if not auto-detected)\n  pipeline?: PipelineStage[];  // Explicit pipeline to execute\n  format?: string;               // Data format hint\n  isRetryable?: boolean;         // Override retryability\n  stream?: boolean;              // Enable streaming for this pipeline\n  \n  // Metadata\n  identifier?: string;           // Variable name for debugging\n  location?: any;               // Source location for errors\n}\n\n/**\n * Process a value through its pipeline (if any)\n * \n * This is the main entry point that should be used by all evaluators.\n * It handles detection, validation, execution, and type preservation.\n */\n/**\n * Process a value through its pipeline (if any)\n * WHY: Normalize detection across AST/directive sources and handle synthetic source stage injection.\n * GOTCHA: A synthetic __source__ stage is prepended when the base input is retryable (function source).\n */\nexport async function processPipeline(\n  context: UnifiedPipelineContext\n): Promise<any> {\n  const { value, env, node, directive, identifier, descriptorHint } = context;\n  const streamRequested =\n    context.stream ??\n    Boolean(\n      (node as any)?.withClause?.stream ??\n      (directive as any)?.values?.withClause?.stream ??\n      (directive as any)?.meta?.withClause?.stream\n    );\n  const sourceNode = getSourceFunctionFromValue(value);\n  const descriptorFromValue = extractSecurityDescriptor(value, {\n    recursive: true,\n    mergeArrayElements: true\n  });\n  const descriptorFromAst = extractDescriptorFromAst(node, env);\n  if (process.env.MLLD_DEBUG === 'true') {\n    const payload = {\n      nodeType: node?.type,\n      descriptorFromValue,\n      descriptorFromAst,\n      descriptorHint\n    };\n    console.error('[processPipeline] descriptor sources', payload);\n    try {\n      const fs = await import('node:fs');\n      fs.appendFileSync('/tmp/pipeline-debug.log', `${JSON.stringify(payload)}\\n`);\n    } catch {}\n  }\n  let pipelineDescriptor: SecurityDescriptor | undefined =\n    descriptorHint ?? descriptorFromValue ?? descriptorFromAst;\n  const directiveLabels = directive\n    ? (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined\n    : undefined;\n  if (directiveLabels && directiveLabels.length > 0) {\n    pipelineDescriptor = mergeDescriptors(\n      pipelineDescriptor,\n      makeSecurityDescriptor({ labels: directiveLabels })\n    );\n  }\n  if (pipelineDescriptor) {\n    env.recordSecurityDescriptor(pipelineDescriptor);\n  }\n  \n  // Debug detection\n  if (identifier && process.env.MLLD_DEBUG === 'true') {\n    debugPipelineDetection(identifier, node, directive);\n  }\n  \n  // Detect pipeline from various sources\n  let detected: DetectedPipeline | null = null;\n\n  if (context.pipeline) {\n    // Explicit pipeline provided\n    detected = {\n      pipeline: context.pipeline,\n      source: 'directive-values', // Default source\n      format: context.format,\n      isRetryable: context.isRetryable ?? true\n    };\n  } else {\n    // Auto-detect from node/directive\n    detected = detectPipeline(node, directive);\n    // Allow explicit override of retryability\n    if (detected && context.isRetryable !== undefined) {\n      detected.isRetryable = context.isRetryable;\n    }\n    if (detected && detected.pipeline && detected.pipeline.length > 0 && detected.isRetryable === false) {\n      // Default to retryable sources; static inputs retry by reusing original value\n      detected.isRetryable = true;\n    }\n    if (process.env.MLLD_DEBUG === 'true' && identifier) {\n      logger.debug('[processPipeline] Detection result:', {\n        identifier,\n        nodeType: node?.type,\n        hasDetected: !!detected,\n        source: detected?.source,\n        pipelineLength: detected?.pipeline?.length,\n        isRetryable: detected?.isRetryable\n      });\n    }\n  }\n  \n  // No pipeline - return value as-is\n  if (!detected || !detected.pipeline || detected.pipeline.length === 0) {\n    return value;\n  }\n  \n  // Create synthetic source stage if we have a retryable source\n  const SOURCE_STAGE: PipelineCommand = {\n    rawIdentifier: '__source__',\n    identifier: [],\n    args: [],\n    fields: [],\n    rawArgs: []\n  };\n  \n  if (process.env.MLLD_DEBUG === 'true') {\n    logger.debug('[processPipeline] Checking for synthetic source:', {\n      isRetryable: detected.isRetryable,\n      hasValue: !!value,\n      hasMetadata: !!(value && typeof value === 'object' && ('mx' in value || 'internal' in value) && ((value as any).mx || (value as any).internal)),\n      hasSourceFunction: !!sourceNode,\n      valueType: value && typeof value === 'object' && 'type' in value ? value.type : typeof value\n    });\n  }\n  \n  // Keep pipeline stages as defined; retryability handled by executor/state-machine\n  const normalizedPipeline = detected.pipeline;\n\n  // Partition: attach builtin effect commands to the preceding functional stage\n  const { functionalPipeline, hadLeadingEffects } = attachBuiltinEffects(normalizedPipeline);\n  \n  // Validate pipeline functions exist (skip __source__ stage)\n  const pipelineToValidate = functionalPipeline.filter(cmd => cmd.rawIdentifier !== '__source__' && cmd.rawIdentifier !== '__identity__');\n  await validatePipeline(pipelineToValidate, env, identifier);\n  \n  // Prepare input value for pipeline\n  const input = await prepareInput(value, env, pipelineDescriptor);\n  \n  // Create source function for retrying stage 0 if applicable\n  const attachDescriptorToRetryInput = (value: unknown): string | StructuredValue => {\n    if (!pipelineDescriptor) {\n      return value as string | StructuredValue;\n    }\n    const wrapped = isStructuredValue(value) ? value : wrapExecResult(value);\n    applySecurityDescriptorToStructuredValue(wrapped, pipelineDescriptor);\n    setExpressionProvenance(wrapped, pipelineDescriptor);\n    return wrapped;\n  };\n\n  // Create a function that replays the source; for static inputs, reuse the original value\n  let sourceFunction: (() => Promise<string | StructuredValue>) | undefined;\n  if (detected.isRetryable) {\n    if (sourceNode) {\n      sourceFunction = async () => {\n        if (sourceNode.type === 'ExecInvocation') {\n          const { evaluateExecInvocation } = await import('../exec-invocation');\n          const result = await evaluateExecInvocation(sourceNode, env);\n          return attachDescriptorToRetryInput(result.value);\n        }\n        if (sourceNode.type === 'command') {\n          const { evaluateCommand } = await import('../run');\n          const result = await evaluateCommand(sourceNode, env);\n          return attachDescriptorToRetryInput(structuredEnabled ? result.value : String(result.value));\n        }\n        if (sourceNode.type === 'code') {\n          const { evaluateCodeExecution } = await import('../code-execution');\n          const result = await evaluateCodeExecution(sourceNode, env);\n          return attachDescriptorToRetryInput(result.value);\n        }\n        return attachDescriptorToRetryInput(input);\n      };\n    } else {\n      // Static input: retry by returning the same input value\n      const cachedInput = attachDescriptorToRetryInput(input);\n      sourceFunction = async () => cachedInput;\n    }\n  }\n  \n  // Store whether we added a synthetic source stage for context adjustment\n  const hasSyntheticSource = functionalPipeline[0]?.rawIdentifier === '__source__';\n  \n  // Execute pipeline with normalized stages\nlet executionResult: StructuredValue;\n  try {\n    const executor = new PipelineExecutor(\n      functionalPipeline,\n      env,\n      detected.format,\n      detected.isRetryable,\n      sourceFunction,\n      hasSyntheticSource,\n      detected.parallelCap,\n      detected.delayMs\n    );\n    executionResult = await executor.execute(input, {\n      returnStructured: true,\n      stream: streamRequested\n    }) as StructuredValue;\n\n  } catch (error) {\n    // Enhance error with context\n    if (error instanceof Error) {\n      const funcName = detected.pipeline[0]?.rawIdentifier || 'unknown';\n      throw new MlldDirectiveError(\n        `Pipeline execution failed at '@${funcName}': ${error.message}`,\n        'pipeline',\n        { location: context.location }\n      );\n    }\n    throw error;\n  }\n  const errorsMeta =\n    isStructuredValue(executionResult) &&\n    executionResult.metadata &&\n    Array.isArray((executionResult.metadata as any).errors)\n      ? (executionResult.metadata as any).errors as any[]\n      : undefined;\n\n  if (errorsMeta && errorsMeta.length > 0) {\n    const mxManager = env.getContextManager?.();\n    mxManager?.setLatestErrors(errorsMeta);\n    mxManager?.pushGenericContext('parallel', { errors: errorsMeta, timestamp: Date.now() });\n  }\n\n  if (pipelineDescriptor && isStructuredValue(executionResult)) {\n    const metadata: StructuredValueMetadata = {\n      ...(executionResult.metadata || {}),\n      security: pipelineDescriptor\n    };\n    return wrapStructured(executionResult, undefined, undefined, metadata);\n  }\n  if (pipelineDescriptor) {\n    env.recordSecurityDescriptor(pipelineDescriptor);\n  }\n  return executionResult;\n}\n\n/**\n * Validate that all pipeline functions exist\n */\nasync function validatePipeline(\n  pipeline: PipelineStage[],\n  env: Environment,\n  identifier?: string\n): Promise<void> {\n  for (const stage of pipeline) {\n    if (Array.isArray(stage)) {\n      await validatePipeline(stage, env, identifier);\n      continue;\n    }\n    if ((stage as any).type === 'whileStage') {\n      const processorName = getWhileProcessorName(stage as WhilePipelineStage);\n      if (!processorName) {\n        continue;\n      }\n      const variable = env.getVariable(processorName);\n      if (!variable) {\n        throw new MlldDirectiveError(\n          `While processor '@${processorName}' is not defined${identifier ? ` (in @${identifier})` : ''}. ` +\n            `Available functions: ${getAvailableFunctions(env).join(', ')}`,\n          'pipeline'\n        );\n      }\n      if (variable.type !== 'executable' && variable.type !== 'computed') {\n        throw new MlldDirectiveError(\n          `'@${processorName}' is not a function, it's a ${variable.type}${identifier ? ` (in @${identifier})` : ''}`,\n          'pipeline'\n        );\n      }\n      continue;\n    }\n    if ((stage as any).type === 'inlineCommand' || (stage as any).type === 'inlineValue') {\n      continue;\n    }\n    const funcName = stage.rawIdentifier;\n    \n    // Check if it's a built-in transformer\n    if (isBuiltinTransformer(funcName)) {\n      continue;\n    }\n    \n    // Check if it's a defined executable\n    const variable = env.getVariable(funcName);\n    if (!variable) {\n      throw new MlldDirectiveError(\n        `Pipeline function '@${funcName}' is not defined${identifier ? ` (in @${identifier})` : ''}. ` +\n        `Available functions: ${getAvailableFunctions(env).join(', ')}`,\n        'pipeline'\n      );\n    }\n    \n    // Check if it's actually executable\n    if (variable.type !== 'executable' && variable.type !== 'computed') {\n      throw new MlldDirectiveError(\n        `'@${funcName}' is not a function, it's a ${variable.type} variable${identifier ? ` (in @${identifier})` : ''}`,\n        'pipeline'\n      );\n    }\n  }\n}\n\nfunction getWhileProcessorName(stage: WhilePipelineStage): string | undefined {\n  const processor = (stage as any)?.processor;\n  if (!processor) {\n    return undefined;\n  }\n\n  if (processor.commandRef) {\n    const ref = processor.commandRef;\n    if (ref.name) {\n      return ref.name;\n    }\n    if (Array.isArray(ref.identifier)) {\n      const candidate = ref.identifier.map((id: any) => id.identifier || id.content || '').find(Boolean);\n      if (candidate) {\n        return candidate;\n      }\n    } else if (ref.identifier) {\n      return ref.identifier;\n    }\n  }\n\n  if (processor.identifier) {\n    return processor.identifier;\n  }\n\n  if (Array.isArray(processor.identifier) && processor.identifier[0]?.identifier) {\n    return processor.identifier[0].identifier;\n  }\n\n  if (processor.rawIdentifier) {\n    return processor.rawIdentifier;\n  }\n\n  return undefined;\n}\n\n// Note: attachBuiltinEffects is imported from './effects-attachment' above.\n\n/**\n * Prepare input value for pipeline processing\n * \n * Converts Variables and other types to strings as needed.\n * In the future, this will handle type preservation.\n */\nasync function prepareInput(\n  value: any,\n  env: Environment,\n  descriptor?: SecurityDescriptor\n): Promise<string | StructuredValue> {\n  return prepareStructuredInput(value, env, undefined, descriptor);\n}\n\nasync function prepareStructuredInput(\n  value: any,\n  env: Environment,\n  incomingMetadata?: StructuredValueMetadata,\n  providedDescriptor?: SecurityDescriptor\n): Promise<StructuredValue> {\n  const sourceDescriptor = providedDescriptor ?? extractSecurityDescriptor(value, {\n    recursive: true,\n    mergeArrayElements: true\n  });\n  const finalizeWrapper = (wrapper: StructuredValue): StructuredValue => {\n    if (sourceDescriptor) {\n      applySecurityDescriptorToStructuredValue(wrapper, sourceDescriptor);\n      setExpressionProvenance(wrapper, sourceDescriptor);\n    } else {\n      inheritExpressionProvenance(wrapper, value);\n    }\n    return wrapper;\n  };\n  const mergedMetadata = (current?: StructuredValueMetadata): StructuredValueMetadata | undefined => {\n    if (!incomingMetadata && !current) {\n      return undefined;\n    }\n    return {\n      ...(current || {}),\n      ...(incomingMetadata || {})\n    };\n  };\n\n  if (isStructuredValue(value)) {\n    const normalizedData = sanitizeStructuredData(value.data);\n    return finalizeWrapper(\n      wrapStructured(normalizedData, value.type, value.text, mergedMetadata(value.metadata))\n    );\n  }\n\n  if (\n    value &&\n    typeof value === 'object' &&\n    'type' in value &&\n    'text' in value &&\n    'data' in value &&\n    typeof (value as any).text === 'string' &&\n    typeof (value as any).type === 'string'\n  ) {\n    const normalizedData = sanitizeStructuredData((value as any).data);\n    return finalizeWrapper(\n      wrapStructured(normalizedData, (value as any).type, (value as any).text, mergedMetadata((value as any).metadata))\n    );\n  }\n\n  if (value && typeof value === 'object' && 'value' in value && ('mx' in value || 'internal' in value)) {\n    const metadata = mergedMetadata(undefined);\n    const nested = await prepareStructuredInput(value.value, env, metadata, providedDescriptor);\n    return finalizeWrapper(nested);\n  }\n\n  if (value && typeof value === 'object') {\n    const { resolveValue, ResolutionContext } = await import('../../utils/variable-resolution');\n    if ('type' in value && 'value' in value && 'name' in value) {\n      const resolved = await resolveValue(value, env, ResolutionContext.PipelineInput);\n      const nested = await prepareStructuredInput(resolved, env, incomingMetadata, providedDescriptor);\n      return finalizeWrapper(nested);\n    }\n  }\n\n  if (typeof value === 'string') {\n    return finalizeWrapper(ensureStructuredValue(value, 'text', value, incomingMetadata));\n  }\n\n  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {\n    return finalizeWrapper(ensureStructuredValue(value, 'text', String(value), incomingMetadata));\n  }\n\n  if (Array.isArray(value)) {\n    const normalizedArray = value.map(item => sanitizeStructuredData(item));\n    return finalizeWrapper(wrapStructured(normalizedArray, 'array', undefined, incomingMetadata));\n  }\n\n  if (value && typeof value === 'object') {\n    const normalizedObject = sanitizeStructuredData(value);\n    return finalizeWrapper(\n      wrapStructured(normalizedObject as Record<string, unknown>, 'object', undefined, incomingMetadata)\n    );\n  }\n\n  return finalizeWrapper(ensureStructuredValue('', 'text', '', incomingMetadata));\n}\n\n/**\n * Get list of available functions for error messages\n */\nfunction getAvailableFunctions(env: Environment): string[] {\n  const funcs: string[] = [];\n  \n  // Add built-in transformers\n  funcs.push(...getBuiltinTransformers());\n  \n  // Add user-defined executables\n  // TODO: Environment should provide a method to list executables\n  // For now, we'll just suggest checking /exe directives\n  \n  return funcs;\n}\n\nfunction sanitizeStructuredData(value: unknown): unknown {\n  return resolveNestedValue(value, { preserveProvenance: true });\n}\n\nfunction extractDescriptorFromAst(node: any, env: Environment): SecurityDescriptor | undefined {\n  if (!node || typeof node !== 'object') {\n    return undefined;\n  }\n  if (node.type === 'ExecInvocation' && node.commandRef) {\n    const execDescriptor =\n      extractDescriptorFromAst(node.commandRef.objectReference, env) ??\n      extractDescriptorFromAst(node.commandRef.objectSource, env);\n    if (execDescriptor) {\n      return execDescriptor;\n    }\n    if (typeof node.commandRef.identifier === 'string') {\n      const variable = env.getVariable(node.commandRef.identifier);\n      if (variable?.mx) {\n        return varMxToSecurityDescriptor(variable.mx);\n      }\n    } else if (Array.isArray(node.commandRef.identifier)) {\n      for (const identifierNode of node.commandRef.identifier) {\n        const descriptor = extractDescriptorFromAst(identifierNode, env);\n        if (descriptor) {\n          return descriptor;\n        }\n      }\n    }\n  }\n\n  if (node.type === 'VariableReference' && typeof node.identifier === 'string') {\n    const variable = env.getVariable(node.identifier);\n    if (variable?.mx) {\n      return varMxToSecurityDescriptor(variable.mx);\n    }\n  }\n\n  if (node.objectReference) {\n    const descriptor = extractDescriptorFromAst(node.objectReference, env);\n    if (descriptor) {\n      return descriptor;\n    }\n  }\n\n  if (node.commandRef?.objectReference) {\n    const descriptor = extractDescriptorFromAst(node.commandRef.objectReference, env);\n    if (descriptor) {\n      return descriptor;\n    }\n  }\n  if (node.commandRef?.objectSource) {\n    const descriptor = extractDescriptorFromAst(node.commandRef.objectSource, env);\n    if (descriptor) {\n      return descriptor;\n    }\n  }\n\n  if (Array.isArray(node.value)) {\n    for (const child of node.value) {\n      const descriptor = extractDescriptorFromAst(child, env);\n      if (descriptor) {\n        return descriptor;\n      }\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Check if a value might need pipeline processing\n * \n * Quick check for optimization - avoids full detection if not needed.\n */\nexport function needsPipelineProcessing(\n  node: any,\n  directive?: any\n): boolean {\n  return !!(\n    node?.pipes?.length ||\n    node?.withClause?.pipeline ||\n    directive?.values?.withClause?.pipeline ||\n    directive?.meta?.withClause?.pipeline\n  );\n}\n\nfunction getSourceFunctionFromValue(value: unknown): any | undefined {\n  if (!value || typeof value !== 'object') {\n    return undefined;\n  }\n  const candidate = value as { internal?: Record<string, unknown> };\n  if (candidate.internal && candidate.internal.sourceFunction) {\n    return candidate.internal.sourceFunction;\n  }\n  return undefined;\n}\n","import { Environment } from '@interpreter/env/Environment';\nimport { MlldError } from '@core/errors';\nimport { llmxmlInstance } from '../utils/llmxml-instance';\nimport type { LoadContentResult } from '@core/types/load-content';\nimport { LoadContentResultImpl, LoadContentResultURLImpl, LoadContentResultHTMLImpl } from './load-content';\nimport { wrapLoadContentValue } from '../utils/load-content-structured';\nimport { glob } from 'tinyglobby';\nimport * as path from 'path';\nimport { extractAst, extractNames, hasNameListPattern, hasContentPattern, type AstResult, type AstPattern } from './ast-extractor';\nimport { MlldDirectiveError } from '@core/errors';\nimport { Readability } from '@mozilla/readability';\nimport TurndownService from 'turndown';\nimport { JSDOM } from 'jsdom';\nimport { processPipeline } from './pipeline/unified-processor';\nimport { wrapStructured, isStructuredValue, ensureStructuredValue, asText } from '../utils/structured-value';\nimport type { StructuredValue, StructuredValueType, StructuredValueMetadata } from '../utils/structured-value';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { makeSecurityDescriptor, mergeDescriptors, type SecurityDescriptor } from '@core/types/security';\nimport { labelsForPath } from '@core/security/paths';\nimport { extractVariableValue } from '../utils/variable-resolution';\nimport { isLoadContentResult } from '@core/types/load-content';\n\nasync function interpolateAndRecord(\n  nodes: any,\n  env: Environment,\n  context: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  const { interpolate } = await import('../core/interpreter');\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n/**\n * Check if a path contains glob patterns\n */\nfunction isGlobPattern(path: string): boolean {\n  return /[\\*\\?\\{\\}\\[\\]]/.test(path);\n}\n\nfunction getRelativeBasePath(env: Environment): string {\n  // Prefer inferred project root; fall back to the current file directory when unavailable\n  const projectRoot = env.getProjectRoot?.() ?? env.getBasePath();\n  return projectRoot || env.getFileDirectory();\n}\n\nfunction formatRelativePath(env: Environment, targetPath: string): string {\n  const basePath = path.resolve(getRelativeBasePath(env));\n  const absoluteTarget = path.resolve(targetPath);\n  const relative = path.relative(basePath, absoluteTarget);\n  return relative ? `./${relative}` : './';\n}\n\n/**\n * Process content loading expressions (<file.md> syntax)\n * Loads content from files or URLs and optionally extracts sections\n * Now supports glob patterns and returns metadata-rich results\n */\nexport async function processContentLoader(node: any, env: Environment): Promise<string | LoadContentResult | LoadContentResult[] | Array<AstResult | null> | string[] | StructuredValue> {\n  if (!node || node.type !== 'load-content') {\n    throw new MlldError('Invalid content loader node', {\n      node: node ? node.type : 'null',\n      expected: 'load-content'\n    });\n  }\n\n  const { source, options, pipes, ast } = node;\n\n  if (!source) {\n    throw new MlldError('Content loader expression missing source', {\n      node: node\n    });\n  }\n\n  // Check if we have a transform template\n  const hasTransform = options?.transform?.type === 'template';\n  // Check if we have pipes\n  const hasPipes = pipes && pipes.length > 0;\n\n  // Reconstruct the path/URL string from the source\n  let pathOrUrl: string;\n  \n  // The source could be the path object directly (from file reference interpolation)\n  // or it could be wrapped in a node with source.type\n  const actualSource = source.type === 'path' || source.type === 'url' ? source : \n                       (source.segments && source.raw !== undefined) ? { ...source, type: 'path' } :\n                       source;\n  \n  if (actualSource.type === 'path') {\n    pathOrUrl = await reconstructPath(actualSource, env);\n  } else if (actualSource.type === 'url') {\n    pathOrUrl = reconstructUrl(actualSource);\n  } else {\n    throw new MlldError(`Unknown content loader source type: ${actualSource.type}`, {\n      sourceType: actualSource.type,\n      expected: ['path', 'url']\n    });\n  }\n\n  // Detect glob pattern from the path\n  const isGlob = isGlobPattern(pathOrUrl);\n\n  // AST extraction takes precedence for local files\n  if (ast && actualSource.type === 'path') {\n    let astPatterns = ast as AstPattern[];\n\n    // Resolve variables in patterns (type-filter-var, name-list-var)\n    astPatterns = await Promise.all(astPatterns.map(async pattern => {\n      if (pattern.type === 'type-filter-var') {\n        const variable = env.getVariable(pattern.identifier);\n        if (!variable) {\n          throw new MlldDirectiveError(\n            `Variable @${pattern.identifier} is not defined`,\n            { identifier: pattern.identifier }\n          );\n        }\n        const varValue = await extractVariableValue(variable, env);\n        const filter = varValue ? String(varValue) : undefined;\n        if (!filter) {\n          throw new MlldDirectiveError(\n            `Variable @${pattern.identifier} is empty`,\n            { identifier: pattern.identifier }\n          );\n        }\n        return { type: 'type-filter', filter, usage: pattern.usage };\n      } else if (pattern.type === 'name-list-var') {\n        const variable = env.getVariable(pattern.identifier);\n        if (!variable) {\n          throw new MlldDirectiveError(\n            `Variable @${pattern.identifier} is not defined`,\n            { identifier: pattern.identifier }\n          );\n        }\n        const varValue = await extractVariableValue(variable, env);\n        const filter = varValue ? String(varValue) : undefined;\n        if (!filter) {\n          throw new MlldDirectiveError(\n            `Variable @${pattern.identifier} is empty`,\n            { identifier: pattern.identifier }\n          );\n        }\n        return { type: 'name-list', filter, usage: pattern.usage };\n      }\n      return pattern;\n    })) as AstPattern[];\n\n    // Validate: cannot mix content patterns with name-list patterns\n    const hasNames = hasNameListPattern(astPatterns);\n    const hasContent = hasContentPattern(astPatterns);\n    if (hasNames && hasContent) {\n      throw new MlldDirectiveError(\n        'Cannot mix content selectors with name-list selectors',\n        { patterns: astPatterns.map(p => p.type) }\n      );\n    }\n\n    // Handle name-list patterns: ??, fn??, var??, class??, etc.\n    if (hasNames) {\n      const loadNameResults = async (): Promise<string[] | Array<{ names: string[]; file: string; relative: string; absolute: string }>> => {\n        // Get the filter from the first name-list pattern (variables already resolved above)\n        const namePattern = astPatterns.find(p =>\n          p.type === 'name-list' || p.type === 'name-list-all'\n        );\n        const filter = namePattern?.type === 'name-list' ? namePattern.filter : undefined;\n        // name-list-all has no filter (returns all names)\n\n        if (isGlob) {\n          // For glob patterns, return per-file structure with metadata\n          const baseDir = env.getFileDirectory();\n          const matches = await glob(pathOrUrl, {\n            cwd: baseDir,\n            absolute: true,\n            followSymlinks: true,\n            ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**']\n          });\n          const results: Array<{ names: string[]; file: string; relative: string; absolute: string }> = [];\n          const fileList = Array.isArray(matches) ? matches : [];\n          for (const filePath of fileList) {\n            try {\n              const content = await env.readFile(filePath);\n              const names = extractNames(content, filePath, filter);\n              if (names.length > 0) {\n                results.push({\n                  names,\n                  file: path.basename(filePath),\n                  relative: formatRelativePath(env, filePath),\n                  absolute: filePath\n                });\n              }\n            } catch {\n              // skip unreadable files\n            }\n          }\n          return results;\n        }\n\n        // Single file - return plain string array\n        const content = await env.readFile(pathOrUrl);\n        return extractNames(content, pathOrUrl, filter);\n      };\n\n      const nameResults = await loadNameResults();\n\n      if (hasPipes) {\n        const piped = await processPipeline({\n          value: nameResults,\n          env,\n          node: { pipes }\n        });\n        return finalizeLoaderResult(piped, { type: 'array' });\n      }\n\n      return finalizeLoaderResult(nameResults, { type: 'array' });\n    }\n\n    // Handle content patterns (definitions, type filters, wildcards)\n    const loadAstResults = async (): Promise<Array<AstResult | null>> => {\n      if (isGlob) {\n        const baseDir = env.getFileDirectory();\n        const matches = await glob(pathOrUrl, {\n          cwd: baseDir,\n          absolute: true,\n          followSymlinks: true,\n          ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**']\n        });\n        const aggregated: Array<AstResult | null> = [];\n        const fileList = Array.isArray(matches) ? matches : [];\n        for (const filePath of fileList) {\n          try {\n            const content = await env.readFile(filePath);\n            const extracted = extractAst(content, filePath, astPatterns);\n            for (const entry of extracted) {\n              if (entry) {\n                aggregated.push({ ...entry, file: filePath });\n              } else {\n                aggregated.push(null);\n              }\n            }\n          } catch {\n            // skip unreadable files\n          }\n        }\n        return aggregated;\n      }\n\n      const content = await env.readFile(pathOrUrl);\n      return extractAst(content, pathOrUrl, astPatterns);\n    };\n\n    const astResults = await loadAstResults();\n\n    if (hasTransform && options?.transform) {\n      const transformed = await applyTemplateToAstResults(astResults, options.transform, env);\n      return finalizeLoaderResult(isGlob ? transformed : transformed[0] ?? '', { type: 'text' });\n    }\n\n    if (hasPipes) {\n      const piped = await processPipeline({\n        value: astResults,\n        env,\n        node: { pipes }\n      });\n      return finalizeLoaderResult(piped, Array.isArray(astResults) ? { type: 'array' } : undefined);\n    }\n\n    return finalizeLoaderResult(astResults, { type: 'array' });\n  }\n\n  try {\n    // URLs can't be globs\n    if (env.isURL(pathOrUrl)) {\n      // Fetch URL with metadata\n      const response = await env.fetchURLWithMetadata(pathOrUrl);\n      \n      // Process content based on content type\n      let processedContent = response.content;\n      const contentType = response.headers['content-type'] || response.headers['Content-Type'] || '';\n      \n      // For HTML content, convert to markdown using Readability + Turndown\n      if (contentType.includes('text/html')) {\n        processedContent = await convertHtmlToMarkdown(response.content, pathOrUrl);\n      }\n      \n      // Extract section if specified\n      if (options?.section) {\n        // Handle section-list patterns (??, ##??, etc.)\n        if (isSectionListPattern(options.section)) {\n          const level = getSectionListLevel(options.section);\n          const sections = listSections(processedContent, level);\n\n          if (hasPipes) {\n            const piped = await processPipeline({\n              value: sections,\n              env,\n              node: { pipes }\n            });\n            return finalizeLoaderResult(piped, { type: 'array', metadata: { url: pathOrUrl } });\n          }\n\n          return finalizeLoaderResult(sections, { type: 'array', metadata: { url: pathOrUrl } });\n        }\n\n        const sectionName = await extractSectionName(options.section, env);\n        // URLs don't have frontmatter, so no file context for rename interpolation\n        const sectionContent = await extractSection(processedContent, sectionName, options.section.renamed, undefined, env);\n\n        // Apply pipes if present\n        if (hasPipes) {\n          const pipedSection = await processPipeline({\n            value: sectionContent,\n            env,\n            node: { pipes }\n          });\n          return finalizeLoaderResult(pipedSection, { type: 'text', metadata: { url: pathOrUrl } });\n        }\n\n        // For URLs with sections, return plain string (backward compatibility)\n        return finalizeLoaderResult(sectionContent, { type: 'text', metadata: { url: pathOrUrl } });\n      }\n      \n      // Create rich URL result with metadata\n      const urlResult = new LoadContentResultURLImpl({\n        content: processedContent,    // Markdown for HTML, raw content for others\n        rawContent: response.content,  // Always the raw response\n        url: pathOrUrl,\n        headers: response.headers,\n        status: response.status\n      });\n      \n      // Apply pipes if present\n      if (hasPipes) {\n        // For LoadContentResult objects, apply pipes to the content\n        const pipedContent = await processPipeline({\n          value: urlResult.content,\n          env,\n          node: { pipes }\n        });\n        // Return a new result with piped content\n        const pipedResult = new LoadContentResultURLImpl({\n          content: pipedContent,\n          rawContent: response.content,\n          url: pathOrUrl,\n          headers: response.headers,\n          status: response.status\n        });\n        return finalizeLoaderResult(pipedResult, { type: 'object', text: asText(pipedContent), metadata: { url: pathOrUrl } });\n      }\n      \n      return finalizeLoaderResult(urlResult, { type: 'object', text: urlResult.content, metadata: { url: pathOrUrl } });\n    }\n    \n    // Handle glob patterns for file paths\n    if (isGlob) {\n      const results = await loadGlobPattern(pathOrUrl, options, env);\n      \n      // Apply transform if specified\n      if (hasTransform && options.transform) {\n        const transformedResults = await applyTransformToResults(results, options.transform, env);\n        return finalizeLoaderResult(transformedResults, { type: 'array' });\n      }\n      \n      // Apply pipes if present\n      if (hasPipes) {\n        // For arrays of results, apply pipes to each result's content\n        const pipedResults = await Promise.all(\n          results.map(async (result) => {\n            const pipedContent = await processPipeline({\n              value: typeof result === 'string' ? result : result.content,\n              env,\n              node: { pipes }\n            });\n            if (typeof result === 'string') {\n              return pipedContent;\n            }\n            return new LoadContentResultImpl({\n              content: pipedContent,\n              filename: result.filename,\n              relative: result.relative,\n              absolute: result.absolute,\n              _rawContent: result._rawContent\n            });\n          })\n        );\n        return finalizeLoaderResult(pipedResults, { type: 'array' });\n      }\n      \n      return finalizeLoaderResult(results, { type: 'array' });\n    }\n    \n    // Single file loading\n    const resolvedFilePath = await env.resolvePath(pathOrUrl);\n    const fileSecurityDescriptor = makeSecurityDescriptor({\n      taint: ['src:file', ...labelsForPath(resolvedFilePath)],\n      sources: [resolvedFilePath]\n    });\n    const securityMetadata = { security: fileSecurityDescriptor };\n    const result = await loadSingleFile(pathOrUrl, options, env, pipes, resolvedFilePath);\n\n    // Handle array results (from section-list patterns)\n    if (Array.isArray(result)) {\n      if (hasPipes) {\n        const piped = await processPipeline({\n          value: result,\n          env,\n          node: { pipes }\n        });\n        return finalizeLoaderResult(piped, { type: 'array', metadata: securityMetadata });\n      }\n      return finalizeLoaderResult(result, { type: 'array', metadata: securityMetadata });\n    }\n\n    // Apply transform if specified (for single file)\n    if (hasTransform && options.transform) {\n      const transformed = await applyTransformToResults([result], options.transform, env);\n      return finalizeLoaderResult(transformed[0], {\n        type: typeof transformed[0] === 'string' ? 'text' : 'object',\n        metadata: securityMetadata\n      });\n    }\n\n    // Apply pipes if present\n    if (hasPipes) {\n      // Check if result is a string (from section extraction) or LoadContentResult\n      if (typeof result === 'string') {\n        const pipedString = await processPipeline({\n          value: result,\n          env,\n          node: { pipes }\n        });\n        return finalizeLoaderResult(pipedString, { type: 'text', metadata: securityMetadata });\n      } else {\n        // For LoadContentResult objects, apply pipes to the content\n        const pipedContent = await processPipeline({\n          value: result.content,\n          env,\n          node: { pipes }\n        });\n        // Return a new result with piped content\n        const pipedResult = new LoadContentResultImpl({\n          content: pipedContent,\n          filename: result.filename,\n          relative: result.relative,\n          absolute: result.absolute,\n          _rawContent: result._rawContent\n        });\n        return finalizeLoaderResult(pipedResult, {\n          type: 'object',\n          text: asText(pipedContent),\n          metadata: securityMetadata\n        });\n      }\n    }\n\n    // Always return the full LoadContentResult object\n    // The smart object will handle string conversion when needed\n    return finalizeLoaderResult(result, {\n      type: typeof result === 'string' ? 'text' : 'object',\n      text: typeof result === 'string' ? result : result.content,\n      metadata: securityMetadata\n    });\n  } catch (error: any) {\n    if (process.env.DEBUG_CONTENT_LOADER) {\n      console.log(`ERROR in processContentLoader: ${error.message}`);\n      console.log(`Error stack:`, error.stack);\n    }\n    \n    // If this is a pipeline/transform error, re-throw it directly to preserve the original error\n    if (error.message && error.message.includes('Unknown transform:')) {\n      throw error;\n    }\n\n    // If this is a security/access denial, preserve the clear error message\n    if (error.message && error.message.includes('Access denied:')) {\n      throw new MlldError(error.message, {\n        path: pathOrUrl,\n        error: error.message\n      });\n    }\n\n    // Otherwise, treat it as a file loading error\n    let errorMessage = `Failed to load content: ${pathOrUrl}`;\n\n    // Add helpful hint for relative paths (but not for XML/HTML ambiguity cases)\n    const hasAngleBracket = pathOrUrl.includes('<') || pathOrUrl.includes('>');\n    if (!hasAngleBracket && !pathOrUrl.startsWith('/') && !pathOrUrl.startsWith('@') && !env.isURL(pathOrUrl)) {\n      errorMessage += `\\n\\nHint: Paths are relative to mlld files. You can make them relative to your project root with the \\`@base/\\` prefix`;\n    }\n\n    throw new MlldError(errorMessage, {\n      path: pathOrUrl,\n      error: error.message\n    });\n  }\n}\n\n/**\n * Load a single file and return LoadContentResult or string (if section extracted)\n */\nasync function loadSingleFile(\n  filePath: string,\n  options: any,\n  env: Environment,\n  pipes?: any[],\n  resolvedPathOverride?: string\n): Promise<LoadContentResult | string | string[]> {\n  const hasPipes = pipes && pipes.length > 0;\n  const resolvedPath = resolvedPathOverride ?? (await env.resolvePath(filePath));\n  // Let Environment handle path resolution and fuzzy matching\n  const rawContent = await env.readFile(resolvedPath);\n  \n  // Check if this is an HTML file and convert to Markdown\n  if (resolvedPath.endsWith('.html') || resolvedPath.endsWith('.htm')) {\n    const markdownContent = await convertHtmlToMarkdown(rawContent, `file://${resolvedPath}`);\n    \n    // Extract section if specified\n    if (options?.section) {\n      // Handle section-list patterns (??, ##??, etc.)\n      if (isSectionListPattern(options.section)) {\n        const level = getSectionListLevel(options.section);\n        const sections = listSections(markdownContent, level);\n        // Return array directly - pipes will be handled by caller\n        return sections;\n      }\n\n      const sectionName = await extractSectionName(options.section, env);\n      // Create file context for rename interpolation\n      const fileContext = new LoadContentResultImpl({\n        content: rawContent,\n        filename: path.basename(resolvedPath),\n        relative: formatRelativePath(env, resolvedPath),\n        absolute: resolvedPath\n      });\n\n      const sectionContent = await extractSection(markdownContent, sectionName, options.section.renamed, fileContext, env);\n\n      // Extract HTML metadata\n      const dom = new JSDOM(rawContent);\n      const doc = dom.window.document;\n\n      const title = doc.querySelector('title')?.textContent || '';\n      const description = doc.querySelector('meta[name=\"description\"]')?.getAttribute('content') ||\n                         doc.querySelector('meta[property=\"og:description\"]')?.getAttribute('content') || '';\n\n      // Always return LoadContentResult to maintain metadata\n      const result = new LoadContentResultHTMLImpl({\n        content: sectionContent,\n        rawHtml: rawContent,\n        filename: path.basename(resolvedPath),\n        relative: formatRelativePath(env, resolvedPath),\n        absolute: resolvedPath,\n        title: title || undefined,\n        description: description || undefined\n      });\n      return result;\n    }\n    \n    // Extract HTML metadata\n    const dom = new JSDOM(rawContent);\n    const doc = dom.window.document;\n    \n    const title = doc.querySelector('title')?.textContent || '';\n    const description = doc.querySelector('meta[name=\"description\"]')?.getAttribute('content') || \n                       doc.querySelector('meta[property=\"og:description\"]')?.getAttribute('content') || '';\n    \n    // Create HTML-specific LoadContentResult with metadata\n    const result = new LoadContentResultHTMLImpl({\n      content: markdownContent,\n      rawHtml: rawContent,\n      filename: path.basename(resolvedPath),\n      relative: formatRelativePath(env, resolvedPath),\n      absolute: resolvedPath,\n      title: title || undefined,\n      description: description || undefined\n    });\n    \n    return result;\n  }\n  \n  // Extract section if specified (for non-HTML files)\n  if (options?.section) {\n    // Handle section-list patterns (??, ##??, etc.)\n    if (isSectionListPattern(options.section)) {\n      const level = getSectionListLevel(options.section);\n      const sections = listSections(rawContent, level);\n      // Return array directly - pipes will be handled by caller\n      return sections;\n    }\n\n    const sectionName = await extractSectionName(options.section, env);\n    // Create file context for rename interpolation\n    const fileContext = new LoadContentResultImpl({\n      content: rawContent,\n      filename: path.basename(resolvedPath),\n      relative: formatRelativePath(env, resolvedPath),\n      absolute: resolvedPath\n    });\n\n    const sectionContent = await extractSection(rawContent, sectionName, options.section.renamed, fileContext, env);\n\n    // Always return LoadContentResult to maintain metadata\n    // The result will have the section content but preserve the full file for frontmatter parsing\n    const result = new LoadContentResultImpl({\n      content: sectionContent,\n      filename: path.basename(resolvedPath),\n      relative: formatRelativePath(env, resolvedPath),\n      absolute: resolvedPath,\n      // Pass the full raw content so frontmatter can be parsed\n      _rawContent: rawContent\n    });\n    return result;\n  }\n  \n  // Create regular LoadContentResult (for non-HTML files)\n  const result = new LoadContentResultImpl({\n    content: rawContent,\n    filename: path.basename(resolvedPath),\n    relative: formatRelativePath(env, resolvedPath),\n    absolute: resolvedPath\n  });\n  \n  return result;\n}\n\n/**\n * Load files matching a glob pattern\n */\nasync function loadGlobPattern(pattern: string, options: any, env: Environment): Promise<LoadContentResult[] | string[]> {\n  const relativeBase = getRelativeBasePath(env);\n  let globCwd = env.getFileDirectory();\n  let globPattern = pattern;\n\n  if (pattern.startsWith('@base/')) {\n    globCwd = relativeBase;\n    globPattern = pattern.slice('@base/'.length);\n  } else if (pattern.startsWith('@root/')) {\n    globCwd = relativeBase;\n    globPattern = pattern.slice('@root/'.length);\n  } else if (path.isAbsolute(pattern)) {\n    globCwd = path.parse(pattern).root || '/';\n    globPattern = path.relative(globCwd, pattern);\n  }\n\n  const computeRelative = (filePath: string): string => formatRelativePath(env, filePath);\n\n  // Use tinyglobby to find matching files\n  let matches: string[];\n  try {\n    matches = await glob(globPattern, {\n      cwd: globCwd,\n      absolute: true,\n      followSymlinks: true,\n      // Ignore common non-text files\n      ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**']\n    });\n  } catch (globError: any) {\n    throw globError;\n  }\n  \n  // Sort by filename for consistent ordering\n  matches.sort();\n  \n  // Load each matching file\n  const results: (LoadContentResult | string)[] = [];\n  \n  for (const filePath of matches) {\n    try {\n      const rawContent = await env.readFile(filePath);\n      \n      // Check if this is an HTML file\n      if (filePath.endsWith('.html') || filePath.endsWith('.htm')) {\n        const markdownContent = await convertHtmlToMarkdown(rawContent, `file://${filePath}`);\n        \n        // Skip files if section extraction is requested and section doesn't exist\n        if (options?.section) {\n          // Handle section-list patterns (??, ##??, etc.)\n          if (isSectionListPattern(options.section)) {\n            const level = getSectionListLevel(options.section);\n            const sections = listSections(markdownContent, level);\n            // For glob patterns with section lists, preserve per-file structure\n            if (sections.length > 0) {\n              results.push({\n                names: sections,\n                file: path.basename(filePath),\n                relative: computeRelative(filePath),\n                absolute: filePath\n              } as any);\n            }\n            continue;\n          }\n\n          const sectionName = await extractSectionName(options.section, env);\n          try {\n            // Create file context for rename interpolation\n            const fileContext = new LoadContentResultImpl({\n              content: rawContent,\n              filename: path.basename(filePath),\n              relative: computeRelative(filePath),\n              absolute: filePath\n            });\n\n            const sectionContent = await extractSection(markdownContent, sectionName, options.section.renamed, fileContext, env);\n\n            // If there's a rename, return the string directly\n            if (options.section.renamed) {\n              results.push(sectionContent);\n            } else {\n              // Extract HTML metadata even for sections\n              const dom = new JSDOM(rawContent);\n              const doc = dom.window.document;\n\n              const title = doc.querySelector('title')?.textContent || '';\n              const description = doc.querySelector('meta[name=\"description\"]')?.getAttribute('content') ||\n                                 doc.querySelector('meta[property=\"og:description\"]')?.getAttribute('content') || '';\n\n              // Use HTML result to preserve metadata\n              results.push(new LoadContentResultHTMLImpl({\n                content: sectionContent,\n                rawHtml: rawContent,\n                filename: path.basename(filePath),\n                relative: computeRelative(filePath),\n                absolute: filePath,\n                title: title || undefined,\n                description: description || undefined\n              }));\n            }\n          } catch (error: any) {\n            // Skip files without the requested section\n            continue;\n          }\n        } else {\n          // No section extraction, create HTML result with metadata\n          const dom = new JSDOM(rawContent);\n          const doc = dom.window.document;\n          \n          const title = doc.querySelector('title')?.textContent || '';\n          const description = doc.querySelector('meta[name=\"description\"]')?.getAttribute('content') || \n                             doc.querySelector('meta[property=\"og:description\"]')?.getAttribute('content') || '';\n          \n          results.push(new LoadContentResultHTMLImpl({\n            content: markdownContent,\n            rawHtml: rawContent,\n            filename: path.basename(filePath),\n            relative: computeRelative(filePath),\n            absolute: filePath,\n            title: title || undefined,\n            description: description || undefined\n          }));\n        }\n      } else {\n        // Non-HTML file handling\n        if (options?.section) {\n          // Handle section-list patterns (??, ##??, etc.)\n          if (isSectionListPattern(options.section)) {\n            const level = getSectionListLevel(options.section);\n            const sections = listSections(rawContent, level);\n            // For glob patterns with section lists, preserve per-file structure\n            if (sections.length > 0) {\n              results.push({\n                names: sections,\n                file: path.basename(filePath),\n                relative: computeRelative(filePath),\n                absolute: filePath\n              } as any);\n            }\n            continue;\n          }\n\n          const sectionName = await extractSectionName(options.section, env);\n          try {\n            // Create file context for rename interpolation\n            const fileContext = new LoadContentResultImpl({\n              content: rawContent,\n              filename: path.basename(filePath),\n              relative: computeRelative(filePath),\n              absolute: filePath\n            });\n\n            const sectionContent = await extractSection(rawContent, sectionName, options.section.renamed, fileContext, env);\n\n            // If there's a rename, we're returning a transformed string that should be used directly\n            if (options.section.renamed) {\n              // For renamed sections, return the string directly (will be collected as string array)\n              results.push(sectionContent as any); // Type assertion needed because results is LoadContentResult[]\n            } else {\n              // Create result with section content, preserving raw content for frontmatter\n              results.push(new LoadContentResultImpl({\n                content: sectionContent,\n                filename: path.basename(filePath),\n                relative: computeRelative(filePath),\n                absolute: filePath,\n                _rawContent: rawContent\n              }));\n            }\n          } catch (error: any) {\n            // Skip files without the requested section\n            continue;\n          }\n        } else {\n          // No section extraction, include full content\n          results.push(new LoadContentResultImpl({\n            content: rawContent,\n            filename: path.basename(filePath),\n            relative: computeRelative(filePath),\n            absolute: filePath\n          }));\n        }\n      }\n    } catch (error: any) {\n      // Skip files that can't be read\n      continue;\n    }\n  }\n\n  // Return the results array directly\n  // The caller will handle wrapping with wrapStructured if needed\n  return results as LoadContentResult[] | string[];\n}\n\n/**\n * Reconstruct path string from path AST node\n */\nasync function reconstructPath(pathNode: any, env: Environment): Promise<string> {\n  if (!pathNode.segments || !Array.isArray(pathNode.segments)) {\n    return (pathNode.raw || '').trim();\n  }\n\n  // If segments contain variable references, we need to interpolate\n  const hasVariables = pathNode.segments.some((seg: any) => seg.type === 'VariableReference');\n  \n  if (hasVariables) {\n    const interpolated = await interpolateAndRecord(pathNode.segments, env);\n    return interpolated.trim();\n  }\n\n  // No variables, simple reconstruction\n  const reconstructed = pathNode.segments.map((segment: any) => {\n    if (segment.type === 'Text') {\n      return segment.content;\n    } else if (segment.type === 'PathSeparator') {\n      return segment.value;\n    }\n    return '';\n  }).join('');\n  \n  // Trim the final path to handle trailing spaces before section markers\n  return reconstructed.trim();\n}\n\n/**\n * Reconstruct URL string from URL AST node\n */\nfunction reconstructUrl(urlNode: any): string {\n  if (urlNode.raw) {\n    return urlNode.raw;\n  }\n  \n  // Reconstruct from parts\n  const { protocol, host, path } = urlNode;\n  return `${protocol}://${host}${path || ''}`;\n}\n\n\n/**\n * Extract section name from section AST node\n */\n/**\n * Check if section node is a section-list pattern\n */\nfunction isSectionListPattern(sectionNode: any): boolean {\n  return sectionNode?.identifier?.type === 'section-list';\n}\n\n/**\n * Get level from section-list pattern\n */\nfunction getSectionListLevel(sectionNode: any): number {\n  return sectionNode?.identifier?.level ?? 0;\n}\n\nasync function extractSectionName(sectionNode: any, env: Environment): Promise<string> {\n  if (!sectionNode || !sectionNode.identifier) {\n    throw new MlldError('Invalid section node', {\n      node: sectionNode\n    });\n  }\n\n  // Section identifier might be Text, VariableReference, array of nodes, or section-list\n  const identifier = sectionNode.identifier;\n\n  if (identifier.type === 'section-list') {\n    throw new MlldError('Section list patterns (??) should be handled separately', {\n      identifierType: identifier.type\n    });\n  }\n\n  if (identifier.type === 'Text') {\n    return identifier.content;\n  } else if (identifier.type === 'VariableReference') {\n    // Import interpolate function\n    return await interpolateAndRecord([identifier], env);\n  } else if (Array.isArray(identifier)) {\n    return await interpolateAndRecord(identifier, env);\n  }\n\n  throw new MlldError('Unable to extract section name', {\n    identifierType: identifier.type\n  });\n}\n\n/**\n * Extract a section from markdown content\n */\nasync function extractSection(content: string, sectionName: string, renamedTitle?: any, fileContext?: LoadContentResult, env?: Environment): Promise<string> {\n  try {\n    let extracted;\n    try {\n      extracted = await llmxmlInstance.getSection(content, sectionName, {\n        includeNested: true\n      });\n    } catch (llmxmlError: any) {\n      throw llmxmlError;\n    }\n\n    if (!extracted) {\n      throw new MlldError(`Section \"${sectionName}\" not found in content`, {\n        sectionName: sectionName,\n        availableSections: await getAvailableSections(content)\n      });\n    }\n\n    // If renamed, apply header transformation\n    if (renamedTitle) {\n      \n      let finalTitle: string;\n      \n      // Check if renamedTitle is a template object or a string\n      if (typeof renamedTitle === 'object' && renamedTitle.type === 'rename-template') {\n        // It's a template with parts that need interpolation\n        if (!fileContext) {\n          throw new MlldError('File context required for template interpolation in rename', {\n            sectionName: sectionName\n          });\n        }\n        \n        \n        // Create an environment for interpolation with the file context bound to <>\n        // Process the template parts, replacing placeholders with actual values\n        const processedParts: any[] = [];\n        for (const part of renamedTitle.parts || []) {\n          if (part.type === 'FileReference' && part.source?.type === 'placeholder') {\n            // Handle <> and <>.field references\n            if (part.fields && part.fields.length > 0) {\n              // Access fields on the file context\n              let value: any = fileContext;\n              for (const field of part.fields) {\n                if (value && typeof value === 'object') {\n                  value = value[field.value];\n                } else {\n                  value = undefined;\n                  break;\n                }\n              }\n              processedParts.push({\n                type: 'Text',\n                content: value !== undefined ? String(value) : ''\n              });\n            } else {\n              // Just <> - use the extracted section content without the header\n              // Remove the first line if it's a markdown header\n              const lines = extracted.split('\\n');\n              let contentWithoutHeader = extracted;\n              if (lines.length > 0 && lines[0].match(/^#+\\s/)) {\n                // Skip the header line\n                contentWithoutHeader = lines.slice(1).join('\\n').trim();\n              }\n              processedParts.push({\n                type: 'Text',\n                content: contentWithoutHeader\n              });\n            }\n          } else {\n            // Regular text parts\n            processedParts.push(part);\n          }\n        }\n        \n        // Interpolate the processed template using the passed environment\n        if (!env) {\n          throw new MlldError('Environment required for template interpolation', {\n            sectionName: sectionName\n          });\n        }\n        finalTitle = await interpolateAndRecord(processedParts, env);\n      } else {\n        // It's a plain string (legacy behavior)\n        finalTitle = renamedTitle;\n      }\n      \n      // Import the shared header transform function\n      const { applyHeaderTransform } = await import('./show');\n      return applyHeaderTransform(extracted, finalTitle);\n    }\n\n    return extracted;\n  } catch (error: any) {\n    throw new MlldError(`Failed to extract section: ${error.message}`, {\n      sectionName: sectionName,\n      error: error.message\n    });\n  }\n}\n\n/**\n * Get list of available sections in markdown content (for error messages)\n */\nasync function getAvailableSections(content: string): Promise<string[]> {\n  try {\n    const headings = await llmxmlInstance.getHeadings(content);\n    return headings.map(h => h.title);\n  } catch {\n    // Fallback to simple regex if llmxml fails\n    const sections: string[] = [];\n    const lines = content.split('\\n');\n\n    for (const line of lines) {\n      const match = line.match(/^#+\\s+(.+)$/);\n      if (match) {\n        sections.push(match[1]);\n      }\n    }\n\n    return sections;\n  }\n}\n\n/**\n * List section headings from markdown content\n * @param content - Markdown content to extract headings from\n * @param level - Heading level to filter (0 = all levels, 1 = H1, 2 = H2, etc.)\n * @returns Array of heading titles (strings)\n */\nfunction listSections(content: string, level?: number): string[] {\n  const lines = content.split('\\n');\n  const headings: string[] = [];\n\n  for (const line of lines) {\n    const match = line.match(/^(#{1,6})\\s+(.+)$/);\n    if (match) {\n      const headingLevel = match[1].length;\n      const title = match[2].trim();\n\n      // Filter by level if specified (level 0 means all headings)\n      if (level === undefined || level === 0 || headingLevel === level) {\n        headings.push(title);\n      }\n    }\n  }\n\n  return headings;\n}\n\n/**\n * Convert HTML to Markdown using Readability + Turndown\n */\nasync function convertHtmlToMarkdown(html: string, url: string): Promise<string> {\n  try {\n    // Create DOM from HTML\n    const dom = new JSDOM(html, { url });\n    const reader = new Readability(dom.window.document);\n    const article = reader.parse();\n    \n    if (!article) {\n      // If Readability can't extract an article, fall back to full HTML conversion\n      const turndownService = new TurndownService({\n        headingStyle: 'atx',\n        codeBlockStyle: 'fenced',\n        bulletListMarker: '-',\n        emDelimiter: '*',\n        strongDelimiter: '**'\n      });\n      return turndownService.turndown(html);\n    }\n    \n    // Convert the extracted article content to Markdown\n    const turndownService = new TurndownService({\n      headingStyle: 'atx',\n      codeBlockStyle: 'fenced',\n      bulletListMarker: '-',\n      emDelimiter: '*',\n      strongDelimiter: '**'\n    });\n    \n    // Build markdown with article metadata\n    let markdown = '';\n    if (article.title) {\n      markdown += `# ${article.title}\\n\\n`;\n    }\n    if (article.byline) {\n      markdown += `*By ${article.byline}*\\n\\n`;\n    }\n    // Skip excerpt for now - it's being added even when we don't want it\n    // if (article.excerpt) {\n    //   markdown += `> ${article.excerpt}\\n\\n`;\n    // }\n    \n    // Convert main content\n    markdown += turndownService.turndown(article.content);\n    \n    // Debug logging\n    \n    return markdown;\n  } catch (error) {\n    // If conversion fails, return the original HTML\n    console.warn('Failed to convert HTML to Markdown:', error);\n    return html;\n  }\n}\n\n/**\n * Apply transform template to array of LoadContentResults\n */\nasync function applyTransformToResults(\n  results: LoadContentResult[],\n  transform: any,\n  env: Environment\n): Promise<string[]> {\n  // Interpolate the processed template for each result\n  const transformed: string[] = [];\n  \n  \n  for (const result of results) {\n    \n    // Create a child environment with the current result bound to <>\n    const childEnv = env.createChild();\n    \n    // Create a special variable for <> placeholder\n    const placeholderVar = {\n      type: 'placeholder',\n      value: result,\n      // Make the LoadContentResult properties available\n      fm: result.fm,\n      content: result.content,\n      filename: result.filename,\n      relative: result.relative,\n      absolute: result.absolute\n    };\n    \n    // Process the template parts\n    const templateParts = transform.parts || [];\n    const processedParts: any[] = [];\n    \n    for (const part of templateParts) {\n      // Check for placeholder: either part.type === 'placeholder' or FileReference with source.type === 'placeholder'\n      const isPlaceholder = part.type === 'placeholder' ||\n        (part.type === 'FileReference' && part.source?.type === 'placeholder');\n\n      if (isPlaceholder) {\n        // Handle <> and <>.field references\n        if (part.fields && part.fields.length > 0) {\n          // Access fields on the result\n          let value: any = result;\n          for (const field of part.fields) {\n            if (value && typeof value === 'object') {\n              const fieldName = field.value;\n              // Handle .mx accessor - use the mx getter on LoadContentResult\n              if (fieldName === 'mx' && typeof value.mx === 'object') {\n                value = value.mx;\n              } else {\n                value = value[fieldName];\n              }\n            } else {\n              value = undefined;\n              break;\n            }\n          }\n          processedParts.push({\n            type: 'Text',\n            content: value !== undefined ? String(value) : ''\n          });\n        } else {\n          // Just <> - use the content\n          processedParts.push({\n            type: 'Text',\n            content: result.content\n          });\n        }\n      } else {\n        // Regular template parts (text, variables)\n        processedParts.push(part);\n      }\n    }\n    \n    // Interpolate the processed template\n    const transformedContent = await interpolateAndRecord(processedParts, childEnv);\n    transformed.push(transformedContent);\n  }\n  \n  return transformed;\n}\n\nasync function applyTemplateToAstResults(\n  results: Array<AstResult | null>,\n  transform: any,\n  env: Environment\n): Promise<string[]> {\n  const transformed: string[] = [];\n\n  for (const result of results) {\n    const templateParts = transform.parts || [];\n    const processedParts: any[] = [];\n\n    for (const part of templateParts) {\n      if (part.type === 'placeholder') {\n        if (!result) {\n          processedParts.push({ type: 'Text', content: '' });\n          continue;\n        }\n\n        if (part.fields && part.fields.length > 0) {\n          let value: any = result;\n          for (const field of part.fields) {\n            if (value && typeof value === 'object') {\n              value = value[field.value];\n            } else {\n              value = undefined;\n              break;\n            }\n          }\n          processedParts.push({\n            type: 'Text',\n            content: value !== undefined && value !== null ? String(value) : ''\n          });\n        } else {\n          processedParts.push({\n            type: 'Text',\n            content: result.code ?? ''\n          });\n        }\n      } else {\n        processedParts.push(part);\n      }\n    }\n\n    const childEnv = env.createChild();\n    const transformedContent = await interpolateAndRecord(processedParts, childEnv);\n    transformed.push(transformedContent);\n  }\n\n  return transformed;\n}\n\nfunction finalizeLoaderResult<T>(\n  value: T,\n  options?: { type?: StructuredValueType; text?: string; metadata?: StructuredValueMetadata }\n): T | StructuredValue {\n  // ADD THIS CHECK FIRST - before any other logic\n  if (isLoadContentResult(value)) {\n    return wrapLoadContentValue(value) as any;\n  }\n\n  if (isStructuredValue(value)) {\n    const metadata = mergeMetadata(value.metadata, options?.metadata);\n    if (!options?.type && !options?.text && (!metadata || metadata === value.metadata)) {\n      return value;\n    }\n    return wrapStructured(value, options?.type, options?.text, metadata);\n  }\n\n  const inferredType = options?.type ?? inferLoaderType(value);\n  const text = options?.text ?? deriveLoaderText(value, inferredType);\n  const metadata = mergeMetadata(undefined, options?.metadata);\n  return ensureStructuredValue(value, inferredType, text, metadata);\n}\n\nfunction inferLoaderType(value: unknown): StructuredValueType {\n  if (typeof value === 'string') {\n    return 'text';\n  }\n  if (Array.isArray(value)) {\n    return 'array';\n  }\n  return 'object';\n}\n\nfunction deriveLoaderText(value: unknown, type: StructuredValueType): string {\n  if (type === 'text') {\n    return typeof value === 'string' ? value : String(value ?? '');\n  }\n\n  if (type === 'array') {\n    if (Array.isArray(value)) {\n      // Check if it's an array of LoadContentResult objects\n      if (value.length > 0 && isLoadContentResult(value[0])) {\n        // Concatenate file contents with \\n\\n separator\n        return value.map(item => item.content ?? '').join('\\n\\n');\n      }\n      // For other arrays (like string arrays from renamed content)\n      return value.map(item => String(item)).join('\\n\\n');\n    }\n    return String(value ?? '');\n  }\n\n  if (type === 'object' && value && typeof value === 'object' && 'content' in value && typeof (value as any).content === 'string') {\n    return (value as any).content;\n  }\n\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value ?? '');\n  }\n}\n\nfunction mergeMetadata(base: StructuredValueMetadata | undefined, extra: StructuredValueMetadata | undefined): StructuredValueMetadata | undefined {\n  const baseSecurity = base?.security;\n  const extraSecurity = extra?.security;\n  const mergedSecurity =\n    baseSecurity && extraSecurity\n      ? mergeDescriptors(baseSecurity, extraSecurity)\n      : baseSecurity ?? extraSecurity;\n\n  const merged = {\n    source: 'load-content' as const,\n    ...(base || {}),\n    ...(extra || {})\n  } as StructuredValueMetadata;\n\n  if (mergedSecurity) {\n    merged.security = mergedSecurity;\n  }\n\n  return merged;\n}\n","import type { Environment } from '../../env/Environment';\nimport type { DataValue } from '@core/types/var';\nimport { processContentLoader } from '../content-loader';\nimport { wrapLoadContentValue } from '@interpreter/utils/load-content-structured';\n\n/**\n * Handles evaluation of load-content data values (<file.md> syntax).\n * \n * This evaluator processes:\n * - File content loading expressions\n * - URL content loading expressions  \n * - Section extraction from content\n */\nexport class LoadContentEvaluator {\n  /**\n   * Checks if this evaluator can handle the given data value\n   */\n  canHandle(value: DataValue): boolean {\n    return value && typeof value === 'object' && value.type === 'load-content';\n  }\n\n  /**\n   * Evaluates load-content expressions to load file or URL content\n   */\n  async evaluate(value: DataValue, env: Environment): Promise<any> {\n    if (!this.canHandle(value)) {\n      throw new Error(`LoadContentEvaluator cannot handle value type: ${value?.type || typeof value}`);\n    }\n    \n    // Use the existing content loader\n    const result = await processContentLoader(value, env);\n    const structured = wrapLoadContentValue(result);\n    return structured;\n  }\n}\n","import type { Environment } from '../../env/Environment';\nimport type { DataValue } from '@core/types/var';\nimport { EvaluationStateManager } from './EvaluationStateManager';\nimport { PrimitiveEvaluator } from './PrimitiveEvaluator';\nimport { CollectionEvaluator } from './CollectionEvaluator';\nimport { VariableReferenceEvaluator } from './VariableReferenceEvaluator';\nimport { ForeachCommandEvaluator } from './ForeachCommandEvaluator';\nimport { ForeachSectionEvaluator } from './ForeachSectionEvaluator';\nimport { LoadContentEvaluator } from './LoadContentEvaluator';\nimport { logger } from '@core/utils/logger';\n\n/**\n * Main coordinator for data value evaluation.\n * \n * This class orchestrates the evaluation of data values by routing them to\n * appropriate specialized evaluators based on their type and structure.\n * It provides a clean separation between coordination logic and implementation\n * details while maintaining all the sophisticated evaluation semantics,\n * caching mechanisms, and performance optimizations.\n * \n * Key Features:\n * - Type-based routing to specialized evaluators\n * - Dependency injection for better testability\n * - Centralized error handling and context\n * - Extensible design for new data value types\n */\nexport class DataValueEvaluator {\n  private readonly stateManager: EvaluationStateManager;\n  private readonly primitiveEvaluator: PrimitiveEvaluator;\n  private readonly collectionEvaluator: CollectionEvaluator;\n  private readonly variableReferenceEvaluator: VariableReferenceEvaluator;\n  private readonly foreachCommandEvaluator: ForeachCommandEvaluator;\n  private readonly foreachSectionEvaluator: ForeachSectionEvaluator;\n  private readonly loadContentEvaluator: LoadContentEvaluator;\n\n  constructor() {\n    // Initialize state manager\n    this.stateManager = new EvaluationStateManager();\n    \n    // Initialize evaluators with dependency injection\n    this.primitiveEvaluator = new PrimitiveEvaluator(this.stateManager);\n    this.collectionEvaluator = new CollectionEvaluator(this.evaluate.bind(this));\n    this.variableReferenceEvaluator = new VariableReferenceEvaluator(this.evaluate.bind(this));\n    this.foreachCommandEvaluator = new ForeachCommandEvaluator();\n    this.foreachSectionEvaluator = new ForeachSectionEvaluator(this.evaluate.bind(this));\n    this.loadContentEvaluator = new LoadContentEvaluator();\n  }\n\n  /**\n   * Evaluates a DataValue, recursively evaluating any embedded directives,\n   * variable references, or templates.\n   * \n   * @param value The data value to evaluate\n   * @param env The evaluation environment\n   * @returns The evaluated result\n   */\n  async evaluate(\n    value: DataValue,\n    env: Environment,\n    options?: { suppressErrors?: boolean }\n  ): Promise<any> {\n    \n    try {\n      // Route to appropriate evaluator based on type\n      if (this.primitiveEvaluator.canHandle(value)) {\n        return await this.primitiveEvaluator.evaluate(value, env);\n      }\n      \n      if (this.collectionEvaluator.canHandle(value)) {\n        const result = await this.collectionEvaluator.evaluate(value, env);\n        return result;\n      }\n      \n      if (this.variableReferenceEvaluator.canHandle(value)) {\n        return await this.variableReferenceEvaluator.evaluate(value, env);\n      }\n      \n      if (this.foreachCommandEvaluator.canHandle(value)) {\n        return await this.foreachCommandEvaluator.evaluate(value, env);\n      }\n      \n      if (this.foreachSectionEvaluator.canHandle(value)) {\n        return await this.foreachSectionEvaluator.evaluate(value, env);\n      }\n      \n      if (this.loadContentEvaluator.canHandle(value)) {\n        return await this.loadContentEvaluator.evaluate(value, env);\n      }\n      \n      // Fallback - return the value as-is\n      logger.warn('Unexpected value type in DataValueEvaluator:', { value });\n      return value;\n      \n    } catch (error) {\n      // Build context string for better error messages\n      const valueTypeField = typeof value === 'object' ? (value as any)?.type : undefined;\n      const identifier = typeof value === 'object' ? (value as any)?.identifier : undefined;\n\n      let contextHint = '';\n      if (identifier) {\n        contextHint = ` (evaluating @${identifier})`;\n      } else if (valueTypeField) {\n        contextHint = ` (evaluating ${valueTypeField})`;\n      }\n\n      // If the original error already has a good message, just re-throw it\n      // Only wrap if the error message is missing or generic\n      const originalMessage = error instanceof Error ? error.message : String(error);\n      if (originalMessage && originalMessage.length > 0 && !originalMessage.includes('undefined')) {\n        throw error;\n      }\n\n      // Wrap with context for generic/empty errors\n      const wrappedError = new Error(\n        `Data evaluation failed${contextHint}: ${originalMessage || 'unknown error'}`\n      );\n      if (error instanceof Error) {\n        wrappedError.stack = error.stack;\n        wrappedError.cause = error;\n      }\n      throw wrappedError;\n    }\n  }\n\n  /**\n   * Gets the state manager for external access (if needed for testing)\n   */\n  getStateManager(): EvaluationStateManager {\n    return this.stateManager;\n  }\n\n  /**\n   * Gets evaluator statistics for monitoring and debugging\n   */\n  getEvaluatorStats(): Record<string, any> {\n    const cacheStats = this.stateManager.getCacheStats();\n    return {\n      cacheSize: cacheStats.size,\n      cacheEntries: cacheStats.entries,\n      evaluatorTypes: [\n        'PrimitiveEvaluator',\n        'CollectionEvaluator', \n        'VariableReferenceEvaluator',\n        'ForeachCommandEvaluator',\n        'ForeachSectionEvaluator'\n      ]\n    };\n  }\n}\n","import type { Environment } from '../env/Environment';\nimport type { DataValue } from '@core/types/var';\nimport { \n  isDirectiveValue,\n  isVariableReferenceValue,\n  isTemplateValue,\n  isPrimitiveValue\n} from '@core/types/var';\nimport { DataValueEvaluator } from './data-values/DataValueEvaluator';\nimport { logger } from '@core/utils/logger';\n\n/**\n * Singleton instance of the main data value evaluator coordinator\n */\nconst dataValueEvaluator = new DataValueEvaluator();\n\n/**\n * Gets the main data value evaluator instance for advanced usage\n */\nexport function getDataValueEvaluator(): DataValueEvaluator {\n  return dataValueEvaluator;\n}\n\n/**\n * Gets evaluator statistics for monitoring and debugging\n */\nexport function getEvaluatorStats(): Record<string, any> {\n  return dataValueEvaluator.getEvaluatorStats();\n}\n\n/**\n * Evaluates a DataValue, recursively evaluating any embedded directives,\n * variable references, or templates.\n * \n * This function serves as the main entry point for data value evaluation\n * and delegates to the DataValueEvaluator coordinator.\n */\nexport async function evaluateDataValue(\n  value: DataValue,\n  env: Environment,\n  options?: { suppressErrors?: boolean }\n): Promise<any> {\n  return await dataValueEvaluator.evaluate(value, env, options);\n}\n\n/**\n * Checks if a data value has been fully evaluated (no unevaluated directives remain)\n */\nexport function isFullyEvaluated(value: DataValue): boolean {\n  if (isPrimitiveValue(value)) {\n    return true;\n  }\n  \n  if (isDirectiveValue(value)) {\n    const stateManager = dataValueEvaluator.getStateManager();\n    const cached = stateManager.getCachedResult(value);\n    return cached?.hit === true;\n  }\n  \n  if (isVariableReferenceValue(value) || isTemplateValue(value)) {\n    return false; // These always need evaluation\n  }\n  \n  if (value?.type === 'object') {\n    return Object.values(value.properties).every(isFullyEvaluated);\n  }\n  \n  if (value?.type === 'array') {\n    return value.items.every(isFullyEvaluated);\n  }\n  \n  return true;\n}\n\n/**\n * Check if a data value contains any unevaluated directives\n */\nexport function hasUnevaluatedDirectives(value: DataValue): boolean {\n  if (isPrimitiveValue(value)) {\n    return false;\n  }\n  \n  if (value?.type === 'Directive') {\n    return true;\n  }\n  \n  // Check for foreach expressions\n  if (value && typeof value === 'object' && value.type === 'foreach') {\n    return true;\n  }\n  \n  // Check for ExecInvocation nodes\n  if (value && typeof value === 'object' && value.type === 'ExecInvocation') {\n    return true;\n  }\n  \n  // Check for command objects (from run directives)\n  if (value && typeof value === 'object' && value.type === 'command' && 'command' in value) {\n    return true;\n  }\n  \n  // Check for wrapped strings (quotes, backticks, brackets)\n  if (value && typeof value === 'object' && 'wrapperType' in value && 'content' in value && Array.isArray(value.content)) {\n    return true;\n  }\n  \n  if (Array.isArray(value)) {\n    return value.some(hasUnevaluatedDirectives);\n  }\n  \n  if (value?.type === 'array' && 'items' in value) {\n    return value.items.some(hasUnevaluatedDirectives);\n  }\n  \n  if (value?.type === 'object' && 'properties' in value) {\n    return Object.values(value.properties).some(hasUnevaluatedDirectives);\n  }\n  \n  if (typeof value === 'object' && value !== null && !value.type) {\n    return Object.values(value).some(hasUnevaluatedDirectives);\n  }\n  \n  return false;\n}\n\n/**\n * Collects any evaluation errors from a data value\n */\nexport function collectEvaluationErrors(\n  value: any,\n  path: string = ''\n): Record<string, Error> {\n  const errors: Record<string, Error> = {};\n  \n  if (value?.__error) {\n    errors[path] = new Error(value.__message);\n    return errors;\n  }\n  \n  if (typeof value === 'object' && value !== null) {\n    for (const [key, propValue] of Object.entries(value)) {\n      const propPath = path ? `${path}.${key}` : key;\n      Object.assign(errors, collectEvaluationErrors(propValue, propPath));\n    }\n  }\n  \n  if (Array.isArray(value)) {\n    for (let i = 0; i < value.length; i++) {\n      const elemPath = `${path}[${i}]`;\n      Object.assign(errors, collectEvaluationErrors(value[i], elemPath));\n    }\n  }\n  \n  return errors;\n}\n","import type { DirectiveNode, VariableReferenceNode } from '@core/types';\nimport type { \n  OutputTarget, \n  OutputTargetFile, \n  OutputTargetStream, \n  OutputTargetEnv, \n  OutputTargetResolver,\n  isFileTarget,\n  isStreamTarget,\n  isEnvTarget,\n  isResolverTarget\n} from '@core/types/output';\nimport type { Variable } from '@core/types/variable';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport { evaluate, interpolate } from '../core/interpreter';\nimport { MlldOutputError } from '@core/errors';\nimport { evaluateDataValue } from './data-value-evaluator';\nimport { isTextLike, isExecutable, isTemplate, createSimpleTextVariable } from '@core/types/variable';\nimport { asText, isStructuredValue } from '@interpreter/utils/structured-value';\nimport { materializeDisplayValue, resolveNestedValue } from '../utils/display-materialization';\nimport { logger } from '@core/utils/logger';\nimport * as path from 'path';\nimport { makeSecurityDescriptor, type DataLabel, type SecurityDescriptor } from '@core/types/security';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { resolveDirectiveExecInvocation } from './directive-replay';\n\nfunction mergeInterpolatedDescriptors(\n  env: Environment,\n  descriptors: SecurityDescriptor[]\n): SecurityDescriptor | undefined {\n  if (descriptors.length === 0) {\n    return undefined;\n  }\n  return descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n}\n\nasync function interpolateAndRecord(\n  nodes: any,\n  env: Environment,\n  context: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  const merged = mergeInterpolatedDescriptors(env, descriptors);\n  if (merged) {\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n\ninterface OutputSourceResult {\n  rawValue: unknown;\n  text: string;\n}\n\n/**\n * Evaluates @output directive with enhanced syntax.\n * \n * Legacy syntax (backward compatible):\n * 1. @output [file.md] - outputs the complete document\n * 2. @output @variable [file.md] - outputs a specific variable's content\n * 3. @output @template(args) [file.md] - outputs parameterized template result\n * 4. @output @command(args) [file.md] - outputs parameterized command result\n * 5. @output \"text content\" [file.md] - outputs literal text\n * \n * Enhanced syntax:\n * 1. @output @variable to \"path/to/file.md\" - file output\n * 2. @output @variable to stdout - standard output\n * 3. @output @variable to stderr - standard error\n * 4. @output @variable to env - environment variable (MLLD_VARIABLE)\n * 5. @output @variable to env:CUSTOM_NAME - custom environment variable\n * 6. @output @variable to @resolver/path/file.md - resolver output\n * 7. @output @variable to \"file.json\" as json - with format specification\n */\nexport async function evaluateOutput(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<EvalResult> {\n  // Check if we're importing - skip execution if so\n  if (env.getIsImporting()) {\n    return { value: null, env };\n  }\n\n  const hasSource = directive.meta?.hasSource;\n  const sourceType = directive.meta?.sourceType;\n  const targetType = directive.meta?.targetType || 'file'; // Default to file\n  const format = directive.meta?.format;\n  // Removed: isLegacy flag - bracket syntax no longer supported\n\n  const securityLabels = (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined;\n\n  try {\n    // Get the content to output\n    let content: string;\n    let descriptorSource: unknown;\n    \n    if (!hasSource) {\n      // @output [file.md] or @output to target - output full document\n      // Get the accumulated document from effect handler (includes both markdown and directive outputs)\n      const effectHandler = env.getEffectHandler();\n      if (effectHandler && typeof effectHandler.getDocument === 'function') {\n        content = effectHandler.getDocument();\n        descriptorSource = content;\n      } else {\n        // Fallback to node formatting if no effect handler\n        try {\n          const nodes = env.getNodes();\n          const { formatOutput } = await import('../output/formatter');\n          content = await formatOutput(nodes, {\n            format: format || 'markdown',\n            variables: env.getAllVariables()\n          });\n          descriptorSource = content;\n        } catch (formatError) {\n          // If there's an error, log it in debug mode\n          if (env.hasVariable('DEBUG')) {\n            const debug = env.getVariable('DEBUG');\n            if (debug && debug.value) {\n              logger.error('Output format error', { error: formatError.message });\n            }\n          }\n          throw formatError;\n        }\n      }\n    } else {\n      // Evaluate source content\n      const sourceResult = await evaluateOutputSource(directive, env, sourceType, context);\n      content = sourceResult.text;\n      descriptorSource = sourceResult.rawValue;\n    }\n    \n    // Apply format transformation if specified\n    if (format) {\n      content = await applyOutputFormat(content, format, env);\n    }\n\n    const materializedContent = materializeDisplayValue(\n      descriptorSource ?? content,\n      undefined,\n      descriptorSource ?? content,\n      content\n    );\n    content = materializedContent.text;\n    if (materializedContent.descriptor) {\n      env.recordSecurityDescriptor(materializedContent.descriptor);\n    }\n    const resolvedValue = resolveNestedValue(descriptorSource ?? content, { preserveProvenance: true });\n    const snapshot = env.getSecuritySnapshot();\n    const securityDescriptor = materializedContent.descriptor ??\n      (snapshot\n        ? makeSecurityDescriptor({\n            labels: snapshot.labels,\n            taint: snapshot.taint,\n            sources: snapshot.sources,\n            policyContext: snapshot.policy\n          })\n        : undefined);\n    \n    // Handle the target\n    // Check if this is a simplified structure from @when actions (has values.path instead of values.target)\n    let target: OutputTarget;\n    if (directive.values.target) {\n      target = directive.values.target as OutputTarget;\n    } else if (directive.values.path) {\n      // Legacy structure from @when actions - create a file target\n      target = {\n        type: 'file',\n        path: directive.values.path,\n        raw: directive.raw?.path || '',\n        meta: { bracketed: true }\n      } as OutputTargetFile;\n    } else {\n      throw new MlldOutputError(\n        'No target specified for output directive',\n        'unknown',\n        { sourceLocation: directive.location, env }\n      );\n    }\n    \n    if (targetType === 'file') {\n      const rawTarget =\n        typeof (target as any)?.raw === 'string'\n          ? (target as any).raw.replace(/^[\"']|[\"']$/g, '')\n          : '';\n      if (rawTarget.startsWith('state://')) {\n        const statePath = rawTarget.replace(/^state:\\/\\//, '');\n        env.recordStateWrite({\n          path: statePath,\n          value: content,\n          operation: 'set',\n          security: securityDescriptor ?? makeSecurityDescriptor()\n        });\n      } else {\n        // File output\n        await outputToFile(target as OutputTargetFile, content, env, directive, resolvedValue, securityDescriptor);\n      }\n    } else if (targetType === 'stream') {\n      // Stream output (stdout/stderr)\n      await outputToStream(target as OutputTargetStream, content, env);\n    } else if (targetType === 'env') {\n      // Environment variable output\n      await outputToEnv(target as OutputTargetEnv, content, env, hasSource ? directive.values.source : null);\n    } else if (targetType === 'resolver') {\n      // Resolver output\n      await outputToResolver(target as OutputTargetResolver, content, env, directive);\n    } else {\n      throw new MlldOutputError(\n        `Unknown target type: ${targetType}`,\n        'unknown',\n        { location: directive.location }\n      );\n    }\n    \n    // Mark that output was used (to suppress default output)\n    (env as any).hasExplicitOutput = true;\n    \n    // Return successful result (no direct output to document)\n    return { value: '', env };\n    \n  } catch (error) {\n    // Log the actual error for debugging\n    if (env.hasVariable('DEBUG')) {\n      const debug = env.getVariable('DEBUG');\n      if (debug && debug.value) {\n        logger.error('Output directive error', { \n          error: error.message,\n          stack: error.stack \n        });\n      }\n    }\n    \n    if (error instanceof Error) {\n      throw new MlldOutputError(\n        `Failed to process output: ${error.message}`,\n        format || 'unknown',\n        { sourceLocation: directive.location, env, cause: error }\n      );\n    }\n    throw error;\n  }\n}\n\n/**\n * Evaluates the source content for output\n */\nexport async function evaluateOutputSource(\n  directive: DirectiveNode,\n  env: Environment,\n  sourceType: string,\n  context?: EvaluationContext\n): Promise<OutputSourceResult> {\n  switch (sourceType) {\n    case 'literal':\n      // @output \"text content\" to target\n      // Handle unified quote/template content\n      const source = directive.values.source;\n      \n      // All literal sources should now be arrays of nodes from UnifiedQuoteOrTemplate\n      if (Array.isArray(source)) {\n        const { interpolate } = await import('../core/interpreter');\n        const text = await interpolateAndRecord(source, env);\n        return { rawValue: text, text };\n      }\n      \n      // Fallback for any unexpected format\n      console.warn('Unexpected literal source format:', source);\n      const fallback = String(source);\n      return { rawValue: fallback, text: fallback };\n      \n    case 'variable':\n      return await evaluateVariableSource(directive, env, context);\n      \n    case 'command':\n      return await evaluateCommandSource(directive, env);\n      \n    case 'exec':\n    case 'execInvocation':\n      return await evaluateExecSource(directive, env);\n      \n    default:\n      throw new MlldOutputError(\n        `Unknown source type: ${sourceType}`,\n        'unknown',\n        { sourceLocation: directive.location, env }\n      );\n  }\n}\n\n/**\n * Evaluates variable source (includes templates and simple variables)\n */\nasync function evaluateVariableSource(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<OutputSourceResult> {\n  // Check if the source has args, which indicates it's an invocation\n  const source = directive.values.source;\n  const hasArgs = source.args && Array.isArray(source.args) && source.args.length > 0;\n  \n  if (hasArgs || directive.subtype === 'outputInvocation' || directive.subtype === 'outputExecInvocation') {\n    // @output @template(args) to target or @output @command(args) to target\n    return await evaluateInvocationSource(directive, env, context);\n  } else {\n    // @output @variable to target - simple variable reference\n    return await evaluateSimpleVariableSource(directive, env, context);\n  }\n}\n\n/**\n * Evaluates parameterized invocation source\n */\nasync function evaluateInvocationSource(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<OutputSourceResult> {\n  const identifierNodes = directive.values.source.identifier;\n  const varName = (identifierNodes && Array.isArray(identifierNodes) && identifierNodes[0]?.identifier) \n    ? identifierNodes[0].identifier \n    : undefined;\n  \n  if (!varName) {\n    throw new MlldOutputError(`Invalid variable reference in output directive`, 'unknown', { sourceLocation: directive.location, env });\n  }\n  const args = directive.values.source.args || [];\n  \n  // Get the variable\n  const variable = findExtractedVariable(context, varName) ?? env.getVariable(varName);\n  \n  if (!variable) {\n    throw new MlldOutputError(\n      `Variable ${varName} not found`,\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n  \n  // For any variable with args, treat it as an invocation\n  if (args.length > 0) {\n    // Create an ExecInvocation node and use the standard evaluator\n    const execNode = {\n      type: 'ExecInvocation',\n      commandRef: {\n        name: varName,\n        identifier: [{\n          type: 'Text',\n          content: varName\n        }],\n        args: args\n      },\n      withClause: null\n    };\n    \n    // Use the standard exec invocation evaluator\n    const result = await resolveDirectiveExecInvocation(directive, env, execNode as any);\n    const text = String(result.value ?? '');\n    return { rawValue: result.value, text };\n    \n  } else if (isTextLike(variable)) {\n    // It's a regular text variable (not a template)\n    const templateContent = variable.value;\n    \n    // Create a child environment for parameter substitution\n    const childEnv = env.createChild();\n    \n    // For regular text variables, interpolate the string\n    const text = await interpolateAndRecord(templateContent, childEnv);\n    return { rawValue: text, text };\n    \n  } else if (isExecutable(variable)) {\n    // It's an executable - need to invoke it properly\n    const definition = variable.value;\n    \n    // Create a child environment for parameter substitution\n    const childEnv = env.createChild();\n    \n    // Bind parameters if any\n    const params = definition.paramNames || [];\n    if (params.length > 0) {\n      for (let i = 0; i < params.length && i < args.length; i++) {\n        const paramName = params[i];\n        const argValue = await evaluateDataValue(args[i], env);\n        const paramVar = createSimpleTextVariable(\n          paramName,\n          String(argValue),\n          {\n            directive: 'var',\n            syntax: 'quoted',\n            hasInterpolation: false,\n            isMultiLine: false\n          },\n          {\n            internal: {\n              isSystem: true,\n              isParameter: true\n            }\n          }\n        );\n        childEnv.set(paramName, paramVar);\n      }\n    }\n    \n    // Execute based on the type\n    let result: string;\n    if (definition.type === 'template') {\n      const templateResult = await interpolateAndRecord(definition.template, childEnv);\n      result = templateResult;\n    } else if (definition.type === 'command') {\n      const command = await interpolateAndRecord(definition.commandTemplate, childEnv);\n      result = await childEnv.executeCommand(command);\n    } else if (definition.type === 'code') {\n      const code = await interpolateAndRecord(definition.codeTemplate, childEnv);\n      result = await childEnv.executeCode(code, definition.language || 'javascript');\n    } else {\n      throw new MlldOutputError(\n        `Unsupported executable type: ${definition.type}`,\n        'unknown',\n        { sourceLocation: directive.location, env }\n      );\n    }\n    \n    const text = String(result ?? '');\n    return { rawValue: result, text };\n    \n  } else {\n    throw new MlldOutputError(\n      `Variable ${varName} is not a template or executable`,\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n}\n\n/**\n * Evaluates simple variable source\n */\nasync function evaluateSimpleVariableSource(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<OutputSourceResult> {\n  // The source can be either an object with identifier array or a direct node\n  let varName: string;\n  \n  // Handle different source structures\n  if (directive.values.source.identifier) {\n    // Standard structure from grammar\n    const identifierNodes = directive.values.source.identifier;\n    varName = (identifierNodes && Array.isArray(identifierNodes) && identifierNodes[0]?.identifier) \n      ? identifierNodes[0].identifier \n      : undefined;\n  } else if (Array.isArray(directive.values.source) && directive.values.source[0]?.type === 'VariableReference') {\n    // Legacy structure from older when-actions\n    varName = directive.values.source[0].identifier;\n  } else if (Array.isArray(directive.values.source) && directive.values.source[0]?.type === 'Text') {\n    // Gracefully handle template-as-array passed directly\n    const parts = directive.values.source as any[];\n    const { interpolate } = await import('../core/interpreter');\n    return await interpolateAndRecord(parts as any, env);\n  } else {\n    throw new MlldOutputError(\n      'Invalid source structure for variable output',\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n  \n  const variable = findExtractedVariable(context, varName) ?? env.getVariable(varName);\n  \n  if (!variable) {\n    throw new MlldOutputError(\n      `Variable ${varName} not found`,\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n  \n  // Get the variable value based on type\n  let value: any;\n  \n  if (isTextLike(variable)) {\n    value = variable.value;\n  } else if ('value' in variable) {\n    // Extract Variable value for output - WHY: Output requires raw values to write/display\n    const { extractVariableValue } = await import('../utils/variable-resolution');\n    value = await extractVariableValue(variable, env);\n  } else {\n    throw new MlldOutputError(\n      `Cannot output variable ${varName} - unknown variable type`,\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n\n  let structuredWrapper: any = null;\n  if (isStructuredValue(value)) {\n    structuredWrapper = value;\n    value = value.data;\n  }\n  \n  // Handle field access if present (only for standard structure)\n  const sourceFields = directive.values.source.fields;\n  if (sourceFields && sourceFields.length > 0) {\n    // Process field access\n    for (const field of sourceFields) {\n      if (value === null || value === undefined) {\n        throw new MlldOutputError(\n          `Cannot access field on null or undefined value`,\n          directive.location\n        );\n      }\n      \n      if (field.type === 'arrayIndex') {\n        const index = Number(field.value);\n        if (Array.isArray(value)) {\n          value = value[index];\n        } else {\n          throw new MlldOutputError(\n            `Cannot index non-array value with [${index}]`,\n            directive.location\n          );\n        }\n      } else if (field.type === 'field' || field.type === 'stringIndex' || field.type === 'numericField' || field.type === 'dot') {\n        const fieldName = String(field.value);\n        if (typeof value === 'object' && value !== null) {\n          value = value[fieldName];\n        } else {\n          throw new MlldOutputError(\n            `Cannot access property '${fieldName}' on non-object value`,\n            directive.location\n          );\n        }\n      }\n    }\n  }\n\n  // Convert value to string\n  if (structuredWrapper && (!sourceFields || sourceFields.length === 0)) {\n    return { rawValue: structuredWrapper, text: structuredWrapper.text };\n  }\n\n  const rawValue = value;\n\n  if (typeof value === 'string') {\n    return { rawValue, text: value };\n  } else if (isStructuredValue(value)) {\n    const text = asText(value);\n    return { rawValue: value, text };\n  } else if (typeof value === 'object') {\n    // For objects/arrays, convert to JSON\n    const text = JSON.stringify(value, null, 2);\n    return { rawValue, text };\n  } else {\n    const text = String(value || '');\n    return { rawValue, text };\n  }\n}\n\nfunction findExtractedVariable(\n  context: EvaluationContext | undefined,\n  name: string | undefined\n): Variable | undefined {\n  if (!context?.extractedInputs || !name) {\n    return undefined;\n  }\n  for (const candidate of context.extractedInputs) {\n    if (\n      candidate &&\n      typeof candidate === 'object' &&\n      'name' in candidate &&\n      (candidate as Variable).name === name\n    ) {\n      return candidate as Variable;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Evaluates command source\n */\nasync function evaluateCommandSource(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<OutputSourceResult> {\n  // @output @run @command to target\n  // Execute the command reference\n  const cmdName = directive.values.source.identifier[0].identifier;\n  const cmdArgs = directive.values.source.args || [];\n  \n  // Get the command variable\n  const cmdVariable = env.getVariable(cmdName);\n  \n  if (!isCommandVariable(cmdVariable)) {\n    throw new MlldOutputError(\n      `Variable ${cmdName} is not a command`,\n      directive.location\n    );\n  }\n  \n  // Create a child environment for parameter substitution\n  const cmdChildEnv = env.createChild();\n  \n  // Bind parameters if any\n  if (cmdVariable.params && cmdVariable.params.length > 0) {\n    for (let i = 0; i < cmdVariable.params.length && i < cmdArgs.length; i++) {\n      const paramName = cmdVariable.params[i];\n      const argValue = await evaluateDataValue(cmdArgs[i], env);\n      const paramVar = createSimpleTextVariable(\n        paramName,\n        String(argValue),\n        {\n          directive: 'var',\n          syntax: 'quoted',\n          hasInterpolation: false,\n          isMultiLine: false\n        },\n        {\n          internal: {\n            isSystem: true,\n            isParameter: true\n          }\n        }\n      );\n      cmdChildEnv.setParameterVariable(paramName, paramVar);\n    }\n  }\n  \n  // Execute the command\n  const cmdResult = await evaluate(cmdVariable.value, cmdChildEnv);\n  const text = String(cmdResult.value ?? '');\n  return { rawValue: cmdResult.value, text };\n}\n\n/**\n * Evaluates exec source with tail modifiers\n */\nasync function evaluateExecSource(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<OutputSourceResult> {\n  // @output @command() to target with tail modifiers\n  // Handle ExecInvocation nodes\n  const execInvocationNode = directive.values.source || directive.values.execInvocation;\n  if (execInvocationNode && execInvocationNode.type === 'ExecInvocation') {\n    const result = await resolveDirectiveExecInvocation(directive, env, execInvocationNode);\n    const text = String(result.value ?? '');\n    return { rawValue: result.value, text };\n  } else {\n    throw new MlldOutputError(\n      `Invalid exec invocation source`,\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n}\n\n/**\n * Outputs content to a file\n */\nasync function outputToFile(\n  target: OutputTargetFile,\n  content: string,\n  env: Environment,\n  directive: DirectiveNode\n): Promise<void> {\n  \n  \n  // Evaluate the file path\n  const pathResult = await interpolateAndRecord(target.path, env);\n  let targetPath = String(pathResult);\n  \n  \n  // TODO: This is a hack to handle @base/@root in quoted output paths\n  // The proper fix requires rethinking how @identifier resolution works\n  // across variables, resolvers, and paths in a unified way\n  if (targetPath.startsWith('@base/')) {\n    const projectRoot = env.getProjectRoot();\n    targetPath = path.join(projectRoot, targetPath.substring(6));\n  } else if (targetPath.startsWith('@root/')) {\n    const projectRoot = env.getProjectRoot();\n    targetPath = path.join(projectRoot, targetPath.substring(6));\n  }\n  \n  // Resolve relative paths from the base path\n  if (!path.isAbsolute(targetPath)) {\n    targetPath = path.resolve(env.getBasePath(), targetPath);\n  }\n  \n  // Write the file using the environment's file system\n  const fileSystem = (env as any).fileSystem;\n  if (!fileSystem) {\n    throw new MlldOutputError(\n      'File system not available',\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n  \n  // Ensure directory exists\n  const dirPath = path.dirname(targetPath);\n  try {\n    await fileSystem.mkdir(dirPath, { recursive: true });\n  } catch (err) {\n    // Directory might already exist, that's okay\n  }\n  \n  // Write the file\n  await fileSystem.writeFile(targetPath, content);\n  \n  // Also emit a file effect for tracking/logging purposes\n  env.emitEffect('file', content, { \n    path: targetPath,\n    source: directive.location \n  });\n}\n\n/**\n * Outputs content to a stream (stdout/stderr)\n */\nasync function outputToStream(\n  target: OutputTargetStream,\n  content: string,\n  env: Environment\n): Promise<void> {\n  if (target.stream === 'stdout') {\n    // Use effect type 'stdout' - outputs to stdout only, bypasses document\n    env.emitEffect('stdout', content + '\\n');\n  } else if (target.stream === 'stderr') {\n    // Use effect type 'stderr' - outputs to stderr only\n    env.emitEffect('stderr', content + '\\n');\n  }\n}\n\n/**\n * Outputs content to an environment variable\n */\nasync function outputToEnv(\n  target: OutputTargetEnv,\n  content: string,\n  env: Environment,\n  source: any\n): Promise<void> {\n  let varName: string;\n  \n  if (target.varname) {\n    // Custom environment variable name\n    varName = target.varname;\n  } else {\n    // Default pattern: MLLD_VARIABLE\n    if (source && source.identifier) {\n      const identifierNodes = source.identifier;\n      const sourceVarName = (identifierNodes && Array.isArray(identifierNodes) && identifierNodes[0]?.identifier) \n        ? identifierNodes[0].identifier \n        : undefined;\n      varName = sourceVarName ? `MLLD_${sourceVarName.toUpperCase()}` : 'MLLD_OUTPUT';\n    } else {\n      varName = 'MLLD_OUTPUT';\n    }\n  }\n  \n  // Set the environment variable\n  process.env[varName] = content;\n}\n\n/**\n * Outputs content through a resolver\n */\nasync function outputToResolver(\n  target: OutputTargetResolver,\n  content: string,\n  env: Environment,\n  directive: DirectiveNode\n): Promise<void> {\n  // Get the resolver manager from environment\n  const resolverManager = (env as any).resolverManager;\n  if (!resolverManager) {\n    throw new MlldOutputError(\n      'Resolver manager not available',\n      'unknown',\n      { sourceLocation: directive.location, env }\n    );\n  }\n  \n  // Construct the resolver path\n  const resolverPath = `@${target.resolver}/${target.path.map(p => p.content).join('/')}`;\n  \n  // Heuristic: if resolver name matches a defined variable, user likely meant a variable in the path (needs quotes)\n  const looksLikeVariable = !!env.getVariable(target.resolver);\n  if (looksLikeVariable) {\n    const hintQuoted = `/output @<source> to \"@${target.resolver}/${target.path.map(p => p.content).join('/')}\"`;\n    const hintExplain = `The target '@${target.resolver}/...' is interpreted as a resolver name, not a variable. Quote the path to interpolate variables.`;\n    throw new MlldOutputError(\n      `Unquoted variable in /output target: '@${target.resolver}' is interpreted as a resolver name` +\n        `\\nHint: ${hintExplain}\\nExample: ${hintQuoted}`,\n      'unknown',\n      { sourceLocation: directive.location, env, context: { resolverPath } }\n    );\n  }\n\n  // Placeholder until resolver write support exists\n  throw new MlldOutputError(\n    `Resolver output not yet implemented for ${resolverPath}`,\n    'unknown',\n    { sourceLocation: directive.location, env }\n  );\n}\n\n/**\n * Applies format transformation to content\n */\nasync function applyOutputFormat(\n  content: string,\n  format: string,\n  env: Environment\n): Promise<string> {\n  switch (format) {\n    case 'json':\n      // Try to parse and pretty-print JSON\n      try {\n        const parsed = JSON.parse(content);\n        return JSON.stringify(parsed, null, 2);\n      } catch {\n        // If not valid JSON, return as-is\n        return content;\n      }\n      \n    case 'yaml':\n      // TODO: Implement YAML formatting\n      // For now, return as-is\n      return content;\n      \n    case 'text':\n      // Plain text - strip any formatting\n      return content;\n      \n    default:\n      // Unknown format - return as-is\n      return content;\n  }\n}\n","import type { Environment } from '../env/Environment';\nimport { evaluateForeachCommand, evaluateForeachSection } from '../eval/foreach';\nimport { interpolate } from '../core/interpreter';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { isStructuredValue } from './structured-value';\n\n/**\n * Configuration options for foreach output formatting\n */\nexport interface ForeachOptions {\n  /** Separator between foreach results (default: \"\\n==========\\n\") */\n  separator?: string;\n  /** Template for formatting each result */\n  template?: string;\n}\n\n/**\n * Default options for foreach text formatting\n */\nexport const DEFAULT_FOREACH_OPTIONS: ForeachOptions = {\n  separator: '\\n\\n---\\n\\n'\n};\n\n/**\n * Evaluate a foreach expression and format the results as text\n * \n * @param foreachExpression - The foreach expression from the AST\n * @param env - The evaluation environment\n * @param options - Formatting options\n * @returns Formatted text string\n */\nexport async function evaluateForeachAsText(\n  foreachExpression: any,\n  env: Environment,\n  options: ForeachOptions = {}\n): Promise<string> {\n  // Check if it's a section expression or command expression\n  let results: any;\n  \n  if (foreachExpression.type === 'foreach-section' || \n      (foreachExpression.value && foreachExpression.value.type === 'foreach-section')) {\n    // Handle foreach section expression\n    results = await evaluateForeachSection(foreachExpression, env);\n  } else {\n    // Handle foreach command expression\n    results = await evaluateForeachCommand(foreachExpression, env);\n  }\n  \n  // If no results, return empty string\n  const normalizedResults = Array.isArray(results)\n    ? results\n    : isStructuredValue(results) && Array.isArray(results.data)\n      ? results.data\n      : [results];\n\n  if (normalizedResults.length === 0) {\n    return '';\n  }\n  \n  // Apply default options\n  const finalOptions = { ...DEFAULT_FOREACH_OPTIONS, ...options };\n  \n  // Convert results to strings\n  const stringResults = normalizedResults.map(result => {\n    const normalized = normalizeForeachResultValue(result);\n    if (typeof normalized === 'string') {\n      return normalized;\n    }\n    if (typeof normalized === 'object') {\n      return JSON.stringify(normalized, null, 2);\n    }\n    return String(normalized);\n  });\n  \n  // Apply template if provided\n  if (finalOptions.template) {\n    const templatedResults = await Promise.all(\n      stringResults.map(async (result, index) => {\n        // Create a child environment with special variables\n        const childEnv = env.createChild();\n        \n        // Import variable creation functions\n        const { createSimpleTextVariable, createObjectVariable } = await import('@core/types/variable');\n        const { VariableSource } = await import('@core/types/variable');\n        \n        // Create default source for template variables\n        const templateSource: VariableSource = {\n          directive: 'var',\n          syntax: 'quoted',\n          hasInterpolation: false,\n          isMultiLine: false\n        };\n        \n        // Add template variables using new Variable types\n        childEnv.setVariable('result', createSimpleTextVariable('result', result, templateSource, { mx: templateSource }));\n        childEnv.setVariable('index', createObjectVariable('index', index, false, templateSource, { mx: templateSource }));\n        childEnv.setVariable('item', createSimpleTextVariable('item', result, templateSource, { mx: templateSource }));\n        \n        // Parse and interpolate the template\n        const templateNodes = parseTemplateString(finalOptions.template!);\n        const descriptors: SecurityDescriptor[] = [];\n        const interpolated = await interpolate(templateNodes, childEnv, undefined, {\n          collectSecurityDescriptor: descriptor => {\n            if (descriptor) {\n              descriptors.push(descriptor);\n            }\n          }\n        });\n        if (descriptors.length > 0) {\n          const merged =\n            descriptors.length === 1\n              ? descriptors[0]\n              : childEnv.mergeSecurityDescriptors(...descriptors);\n          childEnv.recordSecurityDescriptor(merged);\n        }\n        return interpolated;\n      })\n    );\n    \n    return templatedResults.join(finalOptions.separator);\n  }\n  \n  // No template, just join with separator\n  return stringResults.join(finalOptions.separator);\n}\n\n/**\n * Parse a template string into interpolation nodes\n * This is a simple parser for templates like \"Q: {{item}}\\nA: {{result}}\"\n */\nfunction parseTemplateString(template: string): any[] {\n  const nodes = [];\n  let current = '';\n  let i = 0;\n  \n  while (i < template.length) {\n    if (template[i] === '{' && template[i + 1] === '{') {\n      // Found start of variable reference\n      if (current) {\n        nodes.push({\n          type: 'Text',\n          nodeId: '',\n          content: current,\n          location: { start: { offset: 0, line: 1, column: 1 }, end: { offset: 0, line: 1, column: 1 } }\n        });\n        current = '';\n      }\n      \n      // Find the end of the variable reference\n      i += 2; // Skip {{\n      let varName = '';\n      while (i < template.length && !(template[i] === '}' && template[i + 1] === '}')) {\n        varName += template[i];\n        i++;\n      }\n      \n      if (i < template.length) {\n        // Add variable reference node\n        nodes.push({\n          type: 'VariableReference',\n          nodeId: '',\n          valueType: 'varIdentifier',\n          identifier: varName.trim(),\n          location: { start: { offset: 0, line: 1, column: 1 }, end: { offset: 0, line: 1, column: 1 } }\n        });\n        i += 2; // Skip }}\n      }\n    } else {\n      current += template[i];\n      i++;\n    }\n  }\n  \n  // Add any remaining text\n  if (current) {\n    nodes.push({\n      type: 'Text',\n      nodeId: '',\n      content: current,\n      location: { start: { offset: 0, line: 1, column: 1 }, end: { offset: 0, line: 1, column: 1 } }\n    });\n  }\n  \n  return nodes;\n}\n\n/**\n * Parse foreach options from a with clause\n * \n * @param withClause - The with clause from the AST\n * @returns Parsed options object\n */\nexport function parseForeachOptions(withClause: any): ForeachOptions {\n  const options: ForeachOptions = {};\n  \n  if (!withClause) {\n    return options;\n  }\n  \n  // Parse separator option\n  if (withClause.separator !== undefined) {\n    if (typeof withClause.separator === 'string') {\n      options.separator = processEscapeSequences(withClause.separator);\n    } else if (withClause.separator && withClause.separator.type === 'Text') {\n      options.separator = processEscapeSequences(withClause.separator.content);\n    }\n  }\n  \n  // Parse template option\n  if (withClause.template !== undefined) {\n    if (typeof withClause.template === 'string') {\n      options.template = processEscapeSequences(withClause.template);\n    } else if (withClause.template && withClause.template.type === 'Text') {\n      options.template = processEscapeSequences(withClause.template.content);\n    }\n  }\n  \n  return options;\n}\n\nfunction normalizeForeachResultValue(value: unknown): unknown {\n  if (isStructuredValue(value)) {\n    return normalizeForeachResultValue(value.data);\n  }\n  if (Array.isArray(value)) {\n    return value.map(item => normalizeForeachResultValue(item));\n  }\n  if (value && typeof value === 'object') {\n    if (isStructuredValueLike(value)) {\n      return normalizeForeachResultValue((value as any).data);\n    }\n    const entries = Object.entries(value as Record<string, unknown>).map(([key, entryValue]) => [\n      key,\n      normalizeForeachResultValue(entryValue)\n    ]);\n    return Object.fromEntries(entries);\n  }\n  if (typeof value === 'string') {\n    try {\n      const parsed = JSON.parse(value);\n      return parsed;\n    } catch {\n      return value;\n    }\n  }\n  return value;\n}\n\nfunction isStructuredValueLike(value: unknown): value is { data?: unknown } {\n  if (!value || typeof value !== 'object') {\n    return false;\n  }\n  return 'data' in (value as Record<string, unknown>) && 'text' in (value as Record<string, unknown>);\n}\n\n/**\n * Process escape sequences in a string\n * Converts \\n to newline, \\t to tab, etc.\n */\nfunction processEscapeSequences(str: string): string {\n  return str\n    .replace(/\\\\n/g, '\\n')\n    .replace(/\\\\t/g, '\\t')\n    .replace(/\\\\r/g, '\\r')\n    .replace(/\\\\\\\\/g, '\\\\')\n    .replace(/\\\\\"/g, '\"')\n    .replace(/\\\\'/g, '\\'');\n}\n","import * as fs from 'fs';\nimport type { DirectiveNode } from '@core/types';\nimport { astLocationToSourceLocation } from '@core/types';\nimport type { Variable } from '@core/types/variable';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult, EvaluationContext } from '../core/interpreter';\nimport { interpolate } from '../core/interpreter';\nimport { JSONFormatter } from '../core/json-formatter';\nimport { formatForDisplay } from '../utils/display-formatter';\nimport { materializeDisplayValue } from '../utils/display-materialization';\nimport { makeSecurityDescriptor, mergeDescriptors } from '@core/types/security';\nimport type { DataLabel, SecurityDescriptor } from '@core/types/security';\n// Remove old type imports - we'll use only the new ones\nimport {\n  isTextLike,\n  isExecutable as isExecutableVar,\n  isSimpleText,\n  isInterpolatedText,\n  isFileContent,\n  isSectionContent,\n  isObject,\n  isArray,\n  isComputed,\n  isCommandResult,\n  isPipelineInput,\n  isImported,\n  isPath,\n  isExecutable,\n  isTemplate,\n  isStructured,\n  isPrimitive,\n  isStructuredValueVariable,\n  createSimpleTextVariable\n} from '@core/types/variable';\nimport { llmxmlInstance } from '../utils/llmxml-instance';\nimport { evaluateDataValue, hasUnevaluatedDirectives } from './data-value-evaluator';\nimport { evaluateForeachAsText, parseForeachOptions } from '../utils/foreach';\nimport { logger } from '@core/utils/logger';\nimport {\n  asText,\n  assertStructuredValue,\n  isStructuredValue,\n  parseAndWrapJson,\n  applySecurityDescriptorToStructuredValue\n} from '@interpreter/utils/structured-value';\n\nimport { wrapExecResult } from '../utils/structured-exec';\nimport { varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\n// Template normalization now handled in grammar - no longer needed here\nimport { resolveDirectiveExecInvocation } from './directive-replay';\n\n/**\n * Evaluate /show directives.\n * Handles variable references, paths, and templates.\n * \n * Ported from AddDirectiveHandler.\n */\nexport async function evaluateShow(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<EvalResult> {\n  // Check if we're importing - skip execution if so\n  if (env.getIsImporting()) {\n    return { value: null, env };\n  }\n\n  if (process.env.MLLD_DEBUG === 'true') {\n  }\n\n  let resultValue: unknown | undefined;\n  let content = '';\n  let skipJsonFormatting = false;\n  const hasErrorMetadata = (val: unknown): boolean =>\n    isStructuredValue(val) &&\n    Array.isArray((val as any).metadata?.errors) &&\n    (val as any).metadata?.errors?.length > 0;\n  const securityLabels = (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined;\n  let isStreamingShow = false;\n  let interpolatedDescriptor: SecurityDescriptor | undefined;\n  const collectInterpolatedDescriptor = (descriptor?: SecurityDescriptor): void => {\n    if (!descriptor) {\n      return;\n    }\n    interpolatedDescriptor = interpolatedDescriptor\n      ? env.mergeSecurityDescriptors(interpolatedDescriptor, descriptor)\n      : descriptor;\n  };\n  const mergePipelineDescriptor = (\n    ...values: (SecurityDescriptor | undefined)[]\n  ): SecurityDescriptor | undefined => {\n    const descriptors = values.filter(Boolean) as SecurityDescriptor[];\n    if (descriptors.length === 0) {\n      return undefined;\n    }\n    if (descriptors.length === 1) {\n      return descriptors[0];\n    }\n    return env.mergeSecurityDescriptors(...descriptors);\n  };\n  const descriptorFromVariable = (variable?: Variable): SecurityDescriptor | undefined => {\n    if (!variable?.mx) {\n      return undefined;\n    }\n    return varMxToSecurityDescriptor(variable.mx);\n  };\n  \n  const directiveLocation = astLocationToSourceLocation(directive.location, env.getCurrentFilePath());\n\n  if (directive.subtype === 'showVariable') {\n    // Handle variable reference - supports both unified AST and legacy structure\n    let variableNode: any;\n    let varName: string;\n    \n    if (directive.values?.invocation) {\n      // New unified AST structure: support VariableReference and VariableReferenceWithTail\n      const invocationNode = directive.values.invocation as any;\n      const allowedTypes = ['VariableReference', 'VariableReferenceWithTail', 'TemplateVariable'] as const;\n      if (!invocationNode || !allowedTypes.includes(invocationNode.type)) {\n        throw new Error('Show variable directive missing variable reference');\n      }\n      variableNode = invocationNode;\n      if (invocationNode.type === 'VariableReference') {\n        varName = invocationNode.identifier;\n      } else if (invocationNode.type === 'VariableReferenceWithTail') {\n        // Extract inner variable identifier for lookup; pipeline handled later\n        const innerVar = invocationNode.variable;\n        if (innerVar.type === 'TemplateVariable') {\n          varName = innerVar.identifier; // __template__\n        } else {\n          varName = innerVar.identifier;\n        }\n      } else if (invocationNode.type === 'TemplateVariable') {\n        varName = invocationNode.identifier; // __template__\n      }\n    } else if (directive.values?.variable) {\n      // Legacy structure (for backwards compatibility during transition)\n      const legacyVariable = directive.values.variable;\n      \n      // Handle both array and single object formats\n      if (!legacyVariable) {\n        throw new Error('Show variable directive missing variable reference');\n      }\n      \n      // When used in when actions, variable might be a single object instead of an array\n      if (Array.isArray(legacyVariable)) {\n        if (legacyVariable.length === 0) {\n          throw new Error('Show variable directive missing variable reference');\n        }\n        variableNode = legacyVariable[0];\n      } else {\n        // Single object format (e.g., from when actions)\n        variableNode = legacyVariable;\n      }\n      \n      // Handle both VariableReference and VariableReferenceWithTail\n      if (variableNode.type === 'VariableReferenceWithTail') {\n        // Extract the actual variable reference and handle pipeline later\n        const innerVar = variableNode.variable;\n        if (innerVar.type === 'TemplateVariable') {\n          // Handle template literals like show \"high\" | @toUpper\n          varName = innerVar.identifier; // Will be __template__\n        } else {\n          varName = innerVar.identifier;\n        }\n        // The pipeline will be handled through variableNode.withClause.pipeline\n      } else if (variableNode.type === 'VariableReference') {\n        varName = variableNode.identifier;\n      } else if (variableNode.type === 'TemplateVariable') {\n        // Handle direct template literals\n        varName = variableNode.identifier; // Will be __template__\n      } else {\n        throw new Error('Show variable directive missing variable reference');\n      }\n    } else {\n      throw new Error('Show variable directive missing variable reference');\n    }\n\n    // NOTE: Do not pre-process pipelines here. For show-invocation, we rely on\n    // evaluateExecInvocation(invocation, env) to execute any attached withClause\n    // (including parallel groups) correctly. Pre-processing here can interfere\n    // with retry/source wiring and produce partial outputs.\n\n    // Get variable from environment or handle template literals\n    let variable: any;\n    let value: any;\n    let originalValue: any; // Keep track of the original value before evaluation\n    let isForeachSection = false; // Track if this came from a foreach-section\n    \n    // Handle template literals (show \"string\" syntax)\n    if (varName === '__template__') {\n      // This is a template literal like show \"high\"\n      // The content is in the TemplateVariable node\n      let templateContent: any;\n      \n      if (variableNode.type === 'VariableReferenceWithTail' && variableNode.variable.type === 'TemplateVariable') {\n        templateContent = variableNode.variable.content;\n      } else if (variableNode.type === 'TemplateVariable') {\n        templateContent = variableNode.content;\n      }\n      \n      // Evaluate the template content (it's an array of AST nodes)\n      if (templateContent) {\n        // For literal strings, the content is typically a single Literal node\n        if (Array.isArray(templateContent) && templateContent.length === 1 && templateContent[0].type === 'Literal') {\n          value = templateContent[0].value;\n        } else {\n          // More complex template - evaluate it\n          const result = await evaluate(templateContent, env);\n          value = result.value;\n        }\n      } else {\n        value = '';\n      }\n      \n      // Skip the variable type checking below since we already have the value\n    } else {\n      // Normal variable reference\n      const extractedVar = getExtractedVariable(context, varName);\n      variable = extractedVar ?? env.getVariable(varName);\n      if (!variable) {\n        throw new Error(`Variable not found: ${varName}`);\n      }\n    }\n\n    // Handle all variable types using the new type guards (skip if we already have a value from template literal)\n    if (value === undefined && variable) {\n      if (isTextLike(variable)) {\n      // All text-producing types: simple, interpolated, template, file, section, command result\n      value = variable.value;\n      \n      // For template variables (like ::{{var}}::), we need to interpolate the template content\n      if (isTemplate(variable)) {\n          // For double-bracket templates, the value is the AST array\n        if (Array.isArray(value)) {\n          if (process.env.MLLD_DEBUG === 'true') {\n            logger.debug('Template interpolation in show', {\n              variableName: variable.name,\n              astArray: value\n            });\n          }\n          value = await interpolate(value, env, undefined, {\n            collectSecurityDescriptor: collectInterpolatedDescriptor\n          });\n          if (process.env.MLLD_DEBUG === 'true') {\n            logger.debug('Interpolation result:', { value });\n          }\n        } else if (variable.internal?.templateAst && Array.isArray(variable.internal.templateAst)) {\n          // GOTCHA: Some legacy paths store template AST in internal metadata\n          value = await interpolate(variable.internal.templateAst, env, undefined, {\n            collectSecurityDescriptor: collectInterpolatedDescriptor\n          });\n        }\n      }\n    } else if (isObject(variable)) {\n      // Object - use the value\n      value = variable.value;\n      originalValue = value;\n      \n      // Check if it's a lazy-evaluated object (still in AST form)\n      if (\n        value &&\n        typeof value === 'object' &&\n        value.type === 'object' &&\n        ('properties' in value || 'entries' in value)\n      ) {\n        // Evaluate the object to get the actual values\n        value = await evaluateDataValue(value, env);\n      }\n    } else if (isArray(variable)) {\n      // Array - use the value\n      value = variable.value;\n      originalValue = value;\n      \n      // Debug logging\n      if (process.env.MLLD_DEBUG === 'true') {\n        logger.debug('show.ts: Processing array variable:', {\n          varName: variable.name,\n          valueType: typeof value,\n          hasType: value && typeof value === 'object' && 'type' in value,\n          typeValue: value && typeof value === 'object' && value.type,\n          hasItems: value && typeof value === 'object' && 'items' in value,\n          isArray: Array.isArray(value),\n          value: value\n        });\n      }\n      \n      // Check if it's a lazy-evaluated array (still in AST form)\n      if (value && typeof value === 'object' && value.type === 'array' && 'items' in value) {\n        // Evaluate the array to get the actual values\n        value = await evaluateDataValue(value, env);\n        \n        // Debug logging\n        if (process.env.MLLD_DEBUG === 'true') {\n          logger.debug('show.ts: After evaluation:', {\n            varName: variable.name,\n            value: value\n          });\n        }\n      }\n    } else if (isComputed(variable)) {\n      // Computed value from code execution\n      value = variable.value;\n    } else if (isPipelineInput(variable)) {\n      // Pipeline input - use the text representation\n      assertStructuredValue(variable.value, 'show:pipeline-input');\n      value = asText(variable.value);\n    } else if (isImported(variable)) {\n      // Imported variable - use the value\n      value = variable.value;\n    } else if (isPath(variable)) {\n      // Path variables contain file path info - read the file\n      const pathValue = variable.value.resolvedPath;\n      const isURL = variable.value.isURL || /^https?:\\/\\//.test(pathValue);\n      \n      try {\n        value = await env.readFile(pathValue);\n      } catch (error) {\n        // Try test hook override if available\n        try {\n          if (isURL) {\n            const override = (globalThis as any).__mlldFetchOverride as (u: string) => Promise<any> | undefined;\n            if (override) {\n              const resp = await override(pathValue);\n              if (resp && typeof resp.text === 'function') {\n                value = await resp.text();\n              } else {\n                value = String(resp);\n              }\n            } else {\n              value = pathValue;\n            }\n          } else {\n            value = pathValue;\n          }\n        } catch {\n          // Fallback to the path itself on any unexpected errors\n          value = pathValue;\n        }\n      }\n    } else if (isExecutable(variable)) {\n      // Show a representation of the executable\n      value = `[executable: ${variable.name}]`;\n    } else if (isPrimitive(variable)) {\n      // Primitive variables (numbers, booleans, null)\n      value = variable.value;\n    } else if (isStructuredValueVariable(variable)) {\n      value = variable.value;\n    } else {\n      throw new Error(`Unknown variable type in show evaluator: ${variable.type}`);\n    }\n\n    // Handle field access BEFORE pipeline processing\n    // For VariableReferenceWithTail, fields are in variableNode.variable.fields\n    // For VariableReference, fields are in variableNode.fields\n    const fieldsToProcess = variableNode?.type === 'VariableReferenceWithTail'\n      ? (variableNode as any).variable?.fields\n      : variableNode?.fields;\n\n    if (fieldsToProcess && fieldsToProcess.length > 0) {\n      const { accessField } = await import('../utils/field-access');\n      const { resolveVariable, ResolutionContext } = await import('../utils/variable-resolution');\n      let fieldTarget: any = variable\n        ? await resolveVariable(variable, env, ResolutionContext.FieldAccess)\n        : value;\n      for (const field of fieldsToProcess) {\n        // Handle variableIndex type - need to resolve the variable first\n        if (field.type === 'variableIndex') {\n          const { evaluateDataValue } = await import('./data-value-evaluator');\n          const indexNode =\n            typeof field.value === 'object'\n              ? (field.value as any)\n              : {\n                  type: 'VariableReference',\n                  valueType: 'varIdentifier',\n                  identifier: String(field.value)\n                };\n          const indexValue = await evaluateDataValue(indexNode as any, env);\n          const resolvedField = { type: 'bracketAccess' as const, value: indexValue };\n          const fieldResult = await accessField(fieldTarget, resolvedField, {\n            preserveContext: true,\n            env,\n            sourceLocation: directiveLocation\n          });\n          value = (fieldResult as any).value;\n        } else {\n          const fieldResult = await accessField(fieldTarget, field, {\n            preserveContext: true,\n            env,\n            sourceLocation: directiveLocation\n          });\n          value = (fieldResult as any).value;\n        }\n        fieldTarget = value;\n        if (value === undefined) break;\n      }\n    }\n\n    // Legacy compatibility: only apply this path when not using unified invocation tail\n    if (!(directive as any)?.values?.invocation) {\n      if (variableNode?.type === 'VariableReferenceWithTail' && variableNode.withClause?.pipeline) {\n        const { processPipeline } = await import('./pipeline/unified-processor');\n        const processed = await processPipeline({\n          value,\n          env,\n          node: variableNode,\n          directive,\n          pipeline: variableNode.withClause.pipeline,\n          identifier: varName,\n          location: directive.location,\n          descriptorHint: mergePipelineDescriptor(descriptorFromVariable(variable), interpolatedDescriptor)\n        });\n        value = processed;\n        if (isStructuredValue(processed)) {\n          content = asText(processed);\n        } else if (typeof processed === 'string') {\n          content = processed;\n        } else {\n          content = JSONFormatter.stringify(processed, { pretty: true });\n        }\n      }\n    }\n    } // Close the if (value === undefined && variable) block\n    \n    // Debug logging for LoadContentResult\n    if (process.env.MLLD_DEBUG === 'true' && variable) {\n      logger.debug('Show variable value:', {\n        varName: variable.name,\n        varType: variable.type,\n        valueType: typeof value,\n        isObject: isObject(variable),\n        valueKeys: value && typeof value === 'object' ? Object.keys(value) : undefined\n      });\n    }\n\n    // Check if the value contains unevaluated directives\n    if (!isStructuredValue(value) && hasUnevaluatedDirectives(value)) {\n      // Evaluate any embedded directives\n      value = await evaluateDataValue(value, env);\n      \n      // After evaluation, check if the original value was a foreach-section\n      if (originalValue && typeof originalValue === 'object' && originalValue.type === 'foreach-section') {\n        isForeachSection = true;\n      }\n    }\n    \n    /**\n     * Extract Variable value for display output\n     * WHY: Display contexts need raw values because users see final content,\n     *      not internal Variable metadata or wrapper objects\n     */\n    const { isVariable, resolveValue, ResolutionContext } = await import('../utils/variable-resolution');\n    value = await resolveValue(value, env, ResolutionContext.Display);\n    const hadFieldAccess = variableNode.fields && variableNode.fields.length > 0;\n    const isNamespaceVariable = variable?.internal?.isNamespace && !hadFieldAccess;\n\n    if (process.env.MLLD_DEBUG_FIX === 'true' && varName === 'complex') {\n      try {\n        fs.appendFileSync(\n          '/tmp/mlld-debug.log',\n          JSON.stringify({\n            source: 'show-variable',\n            name: varName,\n            valueType: typeof value,\n            isStructured: isStructuredValue(value),\n            valuePreview:\n              value && typeof value === 'object'\n                ? {\n                    keys: Object.keys(value).slice(0, 5),\n                    settings: (value as any).config?.settings,\n                    dataKeys: (value as any).data ? Object.keys((value as any).data) : undefined\n                  }\n                : value\n          }) + '\\n'\n        );\n      } catch {}\n    }\n\n    if (isNamespaceVariable && value && typeof value === 'object') {\n      if (process.env.DEBUG_NAMESPACE) {\n        logger.debug('Cleaning namespace for display:', {\n          varName: variable.name,\n          hasMetadata: !!variable.internal,\n          isNamespace: variable.internal?.isNamespace,\n          valueKeys: Object.keys(value)\n        });\n      }\n      content = JSONFormatter.stringifyNamespace(value);\n    } else if (value && typeof value === 'object' && (value as any).__executable) {\n      const params = (value as any).paramNames || [];\n      content = `<function(${params.join(', ')})>`;\n    } else {\n      if (isStructuredValue(value)) {\n        if (hasErrorMetadata(value)) {\n          content = asText(value);\n          skipJsonFormatting = true;\n        } else {\n          content = formatForDisplay(value, { isForeachSection, pretty: true });\n        }\n      } else {\n        if (Array.isArray(value) && process.env.MLLD_DEBUG === 'true') {\n          logger.debug('show.ts: Formatting array:', {\n            varName: variable.name,\n            valueLength: value.length,\n            value,\n            isForeachSection\n          });\n        }\n        content = formatForDisplay(value, { isForeachSection, pretty: false });\n      }\n    }\n    \n    // Legacy path: only run when invocation is not present (avoid double-processing)\n    if (!(directive as any)?.values?.invocation) {\n      if (variableNode?.type === 'VariableReferenceWithTail' && variableNode.withClause?.pipeline) {\n        const { processPipeline } = await import('./pipeline/unified-processor');\n        const processed = await processPipeline({\n          value: content,\n          env,\n          node: variableNode,\n          directive,\n          pipeline: variableNode.withClause.pipeline,\n          identifier: varName,\n          location: directive.location,\n          descriptorHint: mergePipelineDescriptor(descriptorFromVariable(variable), interpolatedDescriptor)\n        });\n      value = processed;\n        if (isStructuredValue(processed)) {\n          content = asText(processed);\n        } else if (typeof processed === 'string') {\n          content = processed;\n        } else {\n          content = JSONFormatter.stringify(processed, { pretty: true });\n        }\n      }\n    }\n    \n    // Unified pipeline processing for showVariable: detect pipeline from invocation or directive\n    try {\n      const { hasPipeline } = await import('./pipeline/detector');\n      const invocationNode = (directive as any)?.values?.invocation;\n      if (hasPipeline(invocationNode, directive)) {\n        const { processPipeline } = await import('./pipeline/unified-processor');\n        // Use direct value; do not inject synthetic source here — avoids stage-0 retry confusion\n        const processed = await processPipeline({\n          value: content,\n          env,\n          node: invocationNode,\n          directive,\n          identifier: varName || 'show',\n          location: directive.location,\n          descriptorHint: mergePipelineDescriptor(descriptorFromVariable(variable), interpolatedDescriptor)\n        });\n      value = processed;\n        if (isStructuredValue(processed)) {\n          content = asText(processed);\n        } else if (typeof processed === 'string') {\n          content = processed;\n        } else {\n          content = JSONFormatter.stringify(processed, { pretty: true });\n        }\n      }\n    } catch {\n      // If no pipeline detected or processing fails, leave content as-is\n    }\n    \n    resultValue = value;\n    \n  } else if (directive.subtype === 'showPath') {\n    // Handle path inclusion (whole file)\n    const pathValue = directive.values?.path;\n    if (!pathValue) {\n      throw new Error('Add path directive missing path');\n    }\n    \n    // Handle both string paths (URLs) and node arrays\n    let resolvedPath: string;\n    if (typeof pathValue === 'string') {\n      // Direct string path (typically URLs)\n      resolvedPath = pathValue;\n    } else if (Array.isArray(pathValue)) {\n      // Array of path nodes\n      resolvedPath = await interpolate(pathValue, env, undefined, {\n        collectSecurityDescriptor: collectInterpolatedDescriptor\n      });\n    } else {\n      throw new Error('Invalid path type in add directive');\n    }\n    \n    if (!resolvedPath) {\n      throw new Error('Add path directive resolved to empty path');\n    }\n    \n    // Read the file content or fetch URL when path is remote\n    if (env.isURL(resolvedPath)) {\n      content = await env.fetchURL(resolvedPath);\n    } else {\n      content = await env.readFile(resolvedPath);\n    }\n    \n  } else if (directive.subtype === 'showPathSection') {\n    // Handle section extraction: @add \"Section Title\" from [file.md]\n    const sectionTitleNodes = directive.values?.sectionTitle;\n    const pathValue = directive.values?.path;\n    \n    if (!sectionTitleNodes || !pathValue) {\n      throw new Error('Add section directive missing section title or path');\n    }\n    \n    // Get the section title\n    const sectionTitle = await interpolate(sectionTitleNodes, env, undefined, {\n      collectSecurityDescriptor: collectInterpolatedDescriptor\n    });\n    \n    // Handle both string paths (URLs) and node arrays\n    let resolvedPath: string;\n    if (typeof pathValue === 'string') {\n      // Direct string path (typically URLs)\n      resolvedPath = pathValue;\n    } else if (Array.isArray(pathValue)) {\n      // Array of path nodes\n      resolvedPath = await interpolate(pathValue, env, undefined, {\n        collectSecurityDescriptor: collectInterpolatedDescriptor\n      });\n    } else {\n      throw new Error('Invalid path type in add section directive');\n    }\n    \n    // Read the file content or fetch URL when path is remote\n    let fileContent: string;\n    if (env.isURL(resolvedPath)) {\n      fileContent = await env.fetchURL(resolvedPath);\n    } else {\n      fileContent = await env.readFile(resolvedPath);\n    }\n    \n    // Extract the section using llmxml\n    try {\n      // getSection expects just the title without the # prefix\n      const titleWithoutHash = sectionTitle.replace(/^#+\\s*/, '');\n      content = await llmxmlInstance.getSection(fileContent, titleWithoutHash, {\n        includeNested: true\n      });\n      // Just trim trailing whitespace\n      content = content.trimEnd();\n    } catch (error) {\n      // Fallback to basic extraction if llmxml fails\n      content = extractSection(fileContent, sectionTitle);\n    }\n    \n    // Handle rename if newTitle is specified\n    const newTitleNodes = directive.values?.newTitle;\n    if (newTitleNodes) {\n      const newTitle = await interpolate(newTitleNodes, env, undefined, {\n        collectSecurityDescriptor: collectInterpolatedDescriptor\n      });\n      // Replace the original section title with the new one\n      const lines = content.split('\\n');\n      if (lines.length > 0 && lines[0].match(/^#+\\s/)) {\n        // Handle three cases:\n        // 1. Just header level: \"###\" -> change level only\n        // 2. No header level: \"Name\" -> keep original level, replace text\n        // 3. Full replacement: \"### Name\" -> replace entire line\n        \n        const newTitleTrimmed = newTitle.trim();\n        const newHeadingMatch = newTitleTrimmed.match(/^(#+)(\\s+(.*))?$/);\n        \n        if (newHeadingMatch) {\n          // Case 1: Just header level (e.g., \"###\")\n          if (!newHeadingMatch[3]) {\n            const originalText = lines[0].replace(/^#+\\s*/, '');\n            lines[0] = `${newHeadingMatch[1]} ${originalText}`;\n          } \n          // Case 3: Full replacement (e.g., \"### Name\")\n          else {\n            lines[0] = newTitleTrimmed;\n          }\n        } else {\n          // Case 2: No header level (e.g., \"Name\")\n          const originalLevel = lines[0].match(/^(#+)\\s/)?.[1] || '#';\n          lines[0] = `${originalLevel} ${newTitleTrimmed}`;\n        }\n        \n        content = lines.join('\\n');\n      } else {\n        // If no heading found, prepend the new title\n        content = newTitle + '\\n' + content;\n      }\n    }\n    \n  } else if (directive.subtype === 'showTemplate') {\n    // Handle template\n    const templateNodes = directive.values?.content;\n    if (!templateNodes) {\n      throw new Error('Add template directive missing content');\n    }\n    \n    \n    // Interpolate the template\n    content = await interpolate(templateNodes, env, undefined, {\n      collectSecurityDescriptor: collectInterpolatedDescriptor\n    });\n    \n    // Handle pipeline if present\n    if (directive.values?.pipeline) {\n      const { executePipeline } = await import('./pipeline');\n      content = await executePipeline(content, directive.values.pipeline, env);\n    }\n    \n    // Template normalization is now handled in the grammar at parse time\n    \n    // Handle section extraction if specified\n    const sectionNodes = directive.values?.section;\n    if (sectionNodes && Array.isArray(sectionNodes)) {\n      const section = await interpolate(sectionNodes, env, undefined, {\n        collectSecurityDescriptor: collectInterpolatedDescriptor\n      });\n      if (section) {\n        content = extractSection(content, section);\n      }\n    }\n    \n  } else if (directive.subtype === 'addInvocation' || directive.subtype === 'showInvocation') {\n    // Handle unified invocation - could be template or exec\n    const baseInvocation = directive.values?.invocation;\n    if (!baseInvocation) {\n      throw new Error('Show invocation directive missing invocation');\n    }\n    isStreamingShow = Boolean(securityLabels?.includes('stream'));\n    const invocation = isStreamingShow\n      ? {\n          ...baseInvocation,\n          withClause: {\n            ...(baseInvocation.withClause || {}),\n            stream: true\n          }\n        }\n      : baseInvocation;\n    \n    // Check if this is a method call on an object or on an exec result\n    const commandRef = invocation.commandRef as any;\n    if (commandRef && (commandRef.objectReference || commandRef.objectSource)) {\n      // This is a method call like @list.includes() - evaluate directly\n      const result = await resolveDirectiveExecInvocation(directive, env, invocation);\n      \n      resultValue = result.value;\n\n      // Convert result to string appropriately\n      if (isStructuredValue(result.value)) {\n        if (result.value.type === 'array' && Array.isArray(result.value.data)) {\n          const cleaned = result.value.data.map(item => (isStructuredValue(item) ? asText(item) : item));\n          content = JSONFormatter.stringify(cleaned, { pretty: true });\n        } else {\n          content = asText(result.value);\n        }\n      } else if (typeof result.value === 'string') {\n        content = result.value;\n      } else if (result.value === null || result.value === undefined) {\n        content = '';\n      } else if (typeof result.value === 'object') {\n        // For objects and arrays, use JSON.stringify\n        content = JSON.stringify(result.value);\n      } else {\n        content = String(result.value);\n      }\n    } else {\n      // Normal invocation - look up the variable\n      const name = commandRef.name || commandRef.identifier?.[0]?.content;\n      if (!name) {\n        throw new Error('Add invocation missing name');\n      }\n      \n      // Look up what this invocation refers to\n      const extracted = getExtractedVariable(context, name);\n      const variable = extracted ?? env.getVariable(name);\n      if (!variable) {\n        throw new Error(`Variable not found: ${name}`);\n      }\n      \n      // Handle based on variable type\n      if (isExecutableVar(variable)) {\n        // This is an executable invocation - use exec-invocation handler\n        const result = await resolveDirectiveExecInvocation(directive, env, invocation);\n        \n        resultValue = result.value;\n\n        // Convert result to string appropriately\n        if (isStructuredValue(result.value)) {\n          if (result.value.type === 'array' && Array.isArray(result.value.data)) {\n            const cleaned = result.value.data.map(item => (isStructuredValue(item) ? asText(item) : item));\n            content = JSONFormatter.stringify(cleaned, { pretty: true });\n          } else {\n            content = asText(result.value);\n          }\n        } else if (typeof result.value === 'string') {\n          content = result.value;\n        } else if (result.value === null || result.value === undefined) {\n          content = '';\n        } else if (typeof result.value === 'object') {\n          // For objects and arrays, use JSON.stringify\n          content = JSON.stringify(result.value);\n        } else {\n          content = String(result.value);\n        }\n      } else {\n        throw new Error(`Variable ${name} is not executable (type: ${variable.type})`);\n      }\n    }\n    \n  } else if (directive.subtype === 'addTemplateInvocation') {\n    // Handle old-style template invocation (for backward compatibility)\n    const templateNameNodes = directive.values?.templateName;\n    if (!templateNameNodes || templateNameNodes.length === 0) {\n      throw new Error('Add template invocation missing template name');\n    }\n    \n    // Get the template name\n    const templateName = await interpolate(templateNameNodes, env, undefined, {\n      collectSecurityDescriptor: collectInterpolatedDescriptor\n    });\n    \n    // Look up the template\n    const template = env.getVariable(templateName);\n    if (!template || template.type !== 'executable') {\n      throw new Error(`Template not found: ${templateName}`);\n    }\n    \n    const definition = template.value;\n    if (definition.type !== 'template') {\n      throw new Error(`Variable ${templateName} is not a template`);\n    }\n    \n    // Get the arguments\n    const args = directive.values?.arguments || [];\n    \n    // Check parameter count\n    if (args.length !== definition.paramNames.length) {\n      throw new Error(`Template ${templateName} expects ${definition.paramNames.length} parameters, got ${args.length}`);\n    }\n    \n    // Create a child environment with the template parameters\n    const childEnv = env.createChild();\n    \n    // Bind arguments to parameters\n    for (let i = 0; i < definition.paramNames.length; i++) {\n      const paramName = definition.paramNames[i];\n      const argValue = args[i];\n      \n      // Convert argument to string value\n      let value: string;\n      if (typeof argValue === 'object' && argValue.type === 'Text') {\n        // Handle Text nodes from the AST\n        value = argValue.content || '';\n      } else if (typeof argValue === 'object' && argValue.type === 'VariableReference') {\n        // Handle variable references like @userName\n        const varName = argValue.identifier;\n        const variable = env.getVariable(varName);\n        if (!variable) {\n          throw new Error(`Variable not found: ${varName}`);\n        }\n        // Get value based on variable type\n        if (isTextLike(variable)) {\n          value = variable.value;\n        } else if (isObject(variable) || isArray(variable)) {\n          value = JSON.stringify(variable.value);\n        } else {\n          value = String(variable.value);\n        }\n      } else if (typeof argValue === 'object' && argValue.type === 'string') {\n        // Legacy format support\n        value = argValue.value;\n      } else if (typeof argValue === 'object' && argValue.type === 'variable') {\n        // Legacy format - handle variable references\n        const varRef = argValue.value;\n        const varName = varRef.identifier;\n        const variable = env.getVariable(varName);\n        if (!variable) {\n          throw new Error(`Variable not found: ${varName}`);\n        }\n        // Get value based on variable type\n        if (isTextLike(variable)) {\n          value = variable.value;\n        } else if (isObject(variable) || isArray(variable)) {\n          value = JSON.stringify(variable.value);\n        } else {\n          value = String(variable.value);\n        }\n      } else {\n        value = String(argValue);\n      }\n      \n      // Create a text variable for the parameter\n      const source = {\n        directive: 'var' as const,\n        syntax: 'quoted' as const,\n        hasInterpolation: false,\n        isMultiLine: false\n      };\n      const variable = createSimpleTextVariable(paramName, value, source);\n      childEnv.setParameterVariable(paramName, variable);\n    }\n    \n    // Interpolate the template content with the child environment\n    // Use definition.template for modern executables, definition.templateContent for legacy\n    const templateNodes = definition.template || definition.templateContent;\n    if (!templateNodes) {\n      throw new Error(`Template ${templateName} has no template content`);\n    }\n    content = await interpolate(templateNodes, childEnv, undefined, {\n      collectSecurityDescriptor: collectInterpolatedDescriptor\n    });\n    \n    // Template normalization is now handled in the grammar at parse time\n    \n  } else if (directive.subtype === 'addForeach') {\n    // Handle foreach expressions for direct output\n    const foreachExpression = directive.values?.foreach;\n    if (!foreachExpression) {\n      throw new Error('Add foreach directive missing foreach expression');\n    }\n    \n    // Parse options from with clause if present\n    const options = parseForeachOptions(foreachExpression.with);\n    \n    // For @add, we want each result on its own line without the heavy separator\n    if (!options.separator) {\n      options.separator = '\\n';\n    }\n    \n    // Evaluate foreach and format as text\n    content = await evaluateForeachAsText(foreachExpression, env, options);\n    \n  } else if (directive.subtype === 'addExecInvocation' || directive.subtype === 'showExecInvocation') {\n    // Handle exec invocation nodes (both legacy add and new show subtypes)\n    const execInvocation = directive.values?.execInvocation;\n    if (!execInvocation) {\n      throw new Error('Show exec invocation directive missing exec invocation');\n    }\n    \n    // Evaluate the exec invocation\n    const result = await resolveDirectiveExecInvocation(directive, env, execInvocation);\n    resultValue = result.value;\n\n    // Convert result to string appropriately\n    if (isStructuredValue(result.value)) {\n      if (hasErrorMetadata(result.value)) {\n        content = asText(result.value);\n        skipJsonFormatting = true;\n      } else {\n        content = formatForDisplay(result.value, { pretty: false });\n      }\n    } else if (typeof result.value === 'string') {\n      content = result.value;\n    } else if (result.value === null || result.value === undefined) {\n      content = '';\n    } else if (typeof result.value === 'object') {\n      // For objects and arrays, use JSON.stringify\n      content = JSON.stringify(result.value);\n    } else {\n      content = String(result.value);\n    }\n    \n  } else if (directive.subtype === 'showForeach') {\n    // Handle foreach expressions for direct output\n    const foreachExpression = directive.values?.foreach;\n    if (!foreachExpression) {\n      throw new Error('Show foreach directive missing foreach expression');\n    }\n    \n    // Parse options from with clause if present\n    const options = parseForeachOptions(foreachExpression.with);\n    \n    // For @show, we want each result on its own line without the heavy separator\n    if (!options.separator) {\n      options.separator = '\\n';\n    }\n    \n    // Evaluate foreach and format as text\n    content = await evaluateForeachAsText(foreachExpression, env, options);\n    \n  } else if (directive.subtype === 'showForeachSection') {\n    // Handle foreach section expressions: @add foreach [@array.field # section] as ::template::\n    const foreachExpression = directive.values?.foreach;\n    if (!foreachExpression) {\n      throw new Error('Add foreach section directive missing foreach expression');\n    }\n    \n    // Evaluate foreach section expression\n    const { ForeachSectionEvaluator } = await import('./data-values/ForeachSectionEvaluator');\n    const { evaluateDataValue } = await import('./data-value-evaluator');\n    const foreachSectionEvaluator = new ForeachSectionEvaluator(evaluateDataValue);\n    const result = await foreachSectionEvaluator.evaluate(foreachExpression, env);\n    \n    // Convert result to string content - should be an array of results\n    if (Array.isArray(result)) {\n      content = result.join('\\n\\n');\n    } else {\n      content = String(result);\n    }\n    \n  } else if (directive.subtype === 'showLoadContent') {\n    // Handle load content expressions: <file.md> or <file.md # Section>\n    const loadContentNode = directive.values?.loadContent;\n    if (!loadContentNode) {\n      throw new Error('Show load content directive missing content loader');\n    }\n    \n    // Use the content loader to process the node\n    const { processContentLoader } = await import('./content-loader');\n    const loadResult = await processContentLoader(loadContentNode, env);\n\n    // Handle different return types from processContentLoader\n    if (isStructuredValue(loadResult)) {\n      resultValue = loadResult;\n      content = asText(loadResult);\n    } else if (typeof loadResult === 'string') {\n      // Backward compatibility - plain string\n      content = loadResult;\n      resultValue = loadResult;\n    } else {\n      try {\n        content = String(loadResult ?? '');\n      } catch {\n        content = '';\n      }\n    }\n    \n    // Handle rename if newTitle is specified (for section extraction)\n    const newTitleNodes = directive.values?.newTitle;\n    if (newTitleNodes && loadContentNode.options?.section) {\n      const newTitle = await interpolate(newTitleNodes, env, undefined, {\n        collectSecurityDescriptor: collectInterpolatedDescriptor\n      });\n      content = applyHeaderTransform(content, newTitle);\n    }\n    \n  } else if (directive.subtype === 'showCommand') {\n    // Handle command execution for display: /show {echo \"test\"}\n    const commandNodes = directive.values?.command;\n    if (!commandNodes) {\n      throw new Error('Show command directive missing command');\n    }\n    \n    // Import necessary dependencies for command execution\n    const { InterpolationContext } = await import('../core/interpolation-context');\n    \n    // Interpolate command (resolve variables) with shell command context\n    const command = await interpolate(commandNodes, env, InterpolationContext.ShellCommand, {\n      collectSecurityDescriptor: collectInterpolatedDescriptor\n    });\n    \n    // Execute the command and capture output for display\n    const executionContext = {\n      sourceLocation: directiveLocation,\n      directiveNode: directive,\n      filePath: env.getCurrentFilePath(),\n      directiveType: 'show'  // Mark as show for context\n    };\n    \n    // Execute command and get output\n    content = await env.executeCommand(command, undefined, executionContext);\n    resultValue = content;\n    \n  } else if (directive.subtype === 'showCode') {\n    // Handle code execution for display: /show js {console.log(\"test\")}\n    const codeNodes = directive.values?.code;\n    const langNodes = directive.values?.lang;\n    \n    if (!codeNodes || !langNodes) {\n      throw new Error('Show code directive missing code or language');\n    }\n    \n    // Inline helper functions (same as in run.ts)\n    function extractRawTextContent(nodes: any[]): string {\n      const parts: string[] = [];\n      for (const node of nodes) {\n        if (node.type === 'Text') {\n          parts.push(node.content || '');\n        } else if (node.type === 'Newline') {\n          parts.push('\\n');\n        } else {\n          parts.push(String((node as any).value || (node as any).content || ''));\n        }\n      }\n      const rawContent = parts.join('');\n      return rawContent.replace(/^\\n/, '');\n    }\n    \n    function dedentCommonIndent(src: string): string {\n      const lines = src.replace(/\\r\\n/g, '\\n').split('\\n');\n      let minIndent: number | null = null;\n      for (const line of lines) {\n        if (line.trim().length === 0) continue;\n        const match = line.match(/^[ \\t]*/);\n        const indent = match ? match[0].length : 0;\n        if (minIndent === null || indent < minIndent) minIndent = indent;\n        if (minIndent === 0) break;\n      }\n      if (!minIndent) return src;\n      return lines.map(l => (l.trim().length === 0 ? '' : l.slice(minIndent!))).join('\\n');\n    }\n    \n    // Get language and code content\n    const lang = extractRawTextContent(langNodes);\n    const code = dedentCommonIndent(extractRawTextContent(codeNodes));\n    \n    // Execute code and capture output for display\n    const executionContext = {\n      sourceLocation: directiveLocation,\n      directiveNode: directive,\n      filePath: env.getCurrentFilePath(),\n      directiveType: 'show'  // Mark as show for context\n    };\n    \n    // Execute code using the unified executeCode method\n    // Note: executeCode handles all language types internally\n    content = await env.executeCode(code, lang, {}, executionContext);\n    resultValue = content;\n    \n  } else if (directive.subtype === 'show' && directive.values?.content) {\n    // Handle simple show directive with content (used in for loops)\n    let templateNodes = directive.values.content;\n\n    // Handle wrapped content structure from for loop actions\n    if (Array.isArray(templateNodes) && templateNodes.length === 1 &&\n        templateNodes[0].content && templateNodes[0].wrapperType) {\n      // Unwrap the content\n      templateNodes = templateNodes[0].content;\n    }\n\n    // Process the content using the standard interpolation\n    content = await interpolate(templateNodes, env, undefined, {\n      collectSecurityDescriptor: collectInterpolatedDescriptor\n    });\n\n  } else if (directive.subtype === 'showLiteral' && directive.values?.content) {\n    // Handle literal show directive (from unified effects pattern)\n    const templateNodes = directive.values.content;\n\n    // Process the content using the standard interpolation\n    content = await interpolate(templateNodes, env, undefined, {\n      collectSecurityDescriptor: collectInterpolatedDescriptor\n    });\n\n  } else {\n    throw new Error(`Unsupported show subtype: ${directive.subtype}`);\n  }\n\n  if (resultValue === undefined) {\n    resultValue = content;\n  }\n\n  // Apply tail pipeline when requested (used by inline /show in templates)\n  const tailPipeline = (directive as any).values?.withClause?.pipeline;\n  if (Array.isArray(tailPipeline) && tailPipeline.length > 0 && (directive as any).meta?.applyTailPipeline) {\n    const { processPipeline } = await import('./pipeline/unified-processor');\n    const pipeline = tailPipeline;\n    const processed = await processPipeline({\n      value: content,\n      env,\n      directive,\n      pipeline,\n      identifier: 'show-tail',\n      location: directive.location,\n      descriptorHint: interpolatedDescriptor\n    });\n    resultValue = processed;\n    if (isStructuredValue(processed)) {\n      content = asText(processed);\n    } else if (typeof processed === 'string') {\n      content = processed;\n    } else {\n      content = JSONFormatter.stringify(processed, { pretty: true });\n    }\n  }\n  \n  // Output directives always end with a newline\n  // This is the interpreter's responsibility, not the grammar's\n  // Final safety: ensure content is a string and pretty-print JSON when possible\n  if (typeof content !== 'string') {\n    try {\n      if (isStructuredValue(content)) {\n        content = asText(content);\n      } else if (Array.isArray(content)) {\n        content = JSONFormatter.stringify(content, { pretty: true });\n      } else if (content !== null && content !== undefined) {\n        content = JSONFormatter.stringify(content, { pretty: true });\n      } else {\n        content = '';\n      }\n    } catch {\n      content = String(content);\n    }\n  } else if (typeof content === 'string' && !skipJsonFormatting) {\n    const parsed = parseAndWrapJson(content, { preserveText: true });\n    if (parsed && typeof parsed !== 'string' && isStructuredValue(parsed)) {\n      content = JSONFormatter.stringify(parsed.data, { pretty: true });\n    }\n  }\n\n  if (resultValue === undefined) {\n    resultValue = content;\n  }\n\n  const displayMaterialized = materializeDisplayValue(content, undefined, resultValue);\n  content = displayMaterialized.text;\n  const textForWrapper = content;\n\n  if (process.env.MLLD_DEBUG_FIX === 'true') {\n    try {\n      fs.appendFileSync(\n        '/tmp/mlld-debug.log',\n        JSON.stringify({\n          source: 'show-final',\n          invocationName: (directive.values as any)?.invocation?.commandRef?.name,\n          contentType: typeof content,\n          contentPreview: typeof content === 'string' ? content.slice(0, 160) : content,\n          resultValueType: typeof resultValue,\n          resultValueIsStructured: resultValue ? (resultValue as any)[Symbol.for('mlld.StructuredValue')] === true : false,\n          resultValueKeys: resultValue && typeof resultValue === 'object' ? Object.keys(resultValue as any).slice(0, 5) : undefined\n        }) + '\\n'\n      );\n    } catch {}\n  }\n\n  if (!content.endsWith('\\n')) {\n    content = `${content}\\n`;\n  }\n\n  const snapshot = env.getSecuritySnapshot();\n  const resultDescriptor = mergeDescriptors(\n    interpolatedDescriptor,\n    displayMaterialized.descriptor,\n    snapshot\n      ? makeSecurityDescriptor({\n          labels: snapshot.labels,\n          taint: snapshot.taint,\n          sources: snapshot.sources,\n          policyContext: snapshot.policy ? { ...snapshot.policy } : undefined\n        })\n      : undefined\n  );\n  \n  // Only emit the effect if we're not in an expression context\n  // In expression contexts (like when expressions), we only return the value\n  if (!context?.isExpression) {\n    // Emit effect with type 'both' - shows on stdout (if streaming) AND adds to document\n    if (!isStreamingShow) {\n      env.emitEffect('both', content, { source: directive.location });\n    }\n  }\n\n  const baseValue = resultValue ?? textForWrapper;\n  const wrapOptions =\n    !isStructuredValue(baseValue) && typeof baseValue !== 'string'\n      ? { text: textForWrapper }\n      : undefined;\n  const wrapped = wrapExecResult(baseValue, wrapOptions);\n  if (resultDescriptor) {\n    applySecurityDescriptorToStructuredValue(wrapped, resultDescriptor);\n  }\n  return { value: wrapped, env };\n}\n\n/**\n * Apply header transformation to content\n * Supports three cases:\n * 1. Just header level: \"###\" -> change level only\n * 2. Just text: \"New Title\" -> keep original level, replace text\n * 3. Full header: \"### New Title\" -> replace entire line\n */\nexport function applyHeaderTransform(content: string, newHeader: string): string {\n  const lines = content.split('\\n');\n  if (lines.length === 0) return newHeader;\n  \n  // Check if first line is a markdown header\n  if (lines[0].match(/^#+\\s/)) {\n    const newHeaderTrimmed = newHeader.trim();\n    const headerMatch = newHeaderTrimmed.match(/^(#+)(\\s+(.*))?$/);\n    \n    if (headerMatch) {\n      if (!headerMatch[3]) {\n        // Case 1: Just header level\n        const originalText = lines[0].replace(/^#+\\s*/, '');\n        lines[0] = `${headerMatch[1]} ${originalText}`;\n      } else {\n        // Case 3: Full replacement\n        lines[0] = newHeaderTrimmed;\n      }\n    } else {\n      // Case 2: Just text, preserve original level\n      const originalLevel = lines[0].match(/^(#+)\\s/)?.[1] || '#';\n      lines[0] = `${originalLevel} ${newHeaderTrimmed}`;\n    }\n  } else {\n    // No header found, prepend the new header\n    lines.unshift(newHeader);\n  }\n  \n  return lines.join('\\n');\n}\n\n// We'll use llmxml for section extraction once it's properly set up\n// For now, keeping the basic implementation\n/**\n * Extract a section from markdown content.\n * TODO: Replace with llmxml.getSection() once integrated\n */\nexport function extractSection(content: string, sectionName: string): string {\n  const lines = content.split('\\\\n');\n  const sectionRegex = new RegExp(`^#+\\\\s+${sectionName}\\\\s*$`, 'i');\n  \n  let inSection = false;\n  let sectionLevel = 0;\n  const sectionLines: string[] = [];\n  \n  for (const line of lines) {\n    // Check if this line starts our section\n    if (!inSection && sectionRegex.test(line)) {\n      inSection = true;\n      sectionLevel = line.match(/^#+/)?.[0].length || 0;\n      continue; // Skip the header itself\n    }\n    \n    // If we're in the section\n    if (inSection) {\n      // Check if we've hit another header at the same or higher level\n      const headerMatch = line.match(/^(#+)\\\\s+/);\n      if (headerMatch && headerMatch[1].length <= sectionLevel) {\n        // We've left the section\n        break;\n      }\n      \n      sectionLines.push(line);\n    }\n  }\n  \n  return sectionLines.join('\\\\n').trim();\n}\nfunction getExtractedVariable(\n  context: EvaluationContext | undefined,\n  name: string\n): Variable | undefined {\n  if (!context?.extractedInputs || context.extractedInputs.length === 0) {\n    return undefined;\n  }\n  for (const candidate of context.extractedInputs) {\n    if (\n      candidate &&\n      typeof candidate === 'object' &&\n      'name' in candidate &&\n      (candidate as Variable).name === name\n    ) {\n      return candidate as Variable;\n    }\n  }\n  return undefined;\n}\n","import * as fs from 'fs';\nimport type { DirectiveNode, VarValue, VariableNodeArray } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult, EvaluationContext } from '../core/interpreter';\nimport { interpolate } from '../core/interpreter';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { astLocationToSourceLocation } from '@core/types';\nimport { logger } from '@core/utils/logger';\nimport { applyHeaderTransform } from './show';\nimport {\n  Variable,\n  VariableSource,\n  VariableMetadataUtils,\n  createSimpleTextVariable,\n  createInterpolatedTextVariable,\n  createTemplateVariable,\n  createArrayVariable,\n  createObjectVariable,\n  createFileContentVariable,\n  createSectionContentVariable,\n  createComputedVariable,\n  createCommandResultVariable,\n  createStructuredValueVariable,\n  createPrimitiveVariable,\n  type VariableMetadata,\n  type VariableContext,\n  type VariableInternalMetadata,\n  type VariableFactoryInitOptions\n} from '@core/types/variable';\nimport type { SecurityDescriptor, DataLabel, CapabilityKind } from '@core/types/security';\nimport { createCapabilityContext, makeSecurityDescriptor } from '@core/types/security';\nimport { isStructuredValue, asText, asData, extractSecurityDescriptor } from '@interpreter/utils/structured-value';\nimport { wrapLoadContentValue } from '@interpreter/utils/load-content-structured';\nimport { updateVarMxFromDescriptor, varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\n\nexport interface VarAssignmentResult {\n  identifier: string;\n  variable: Variable;\n  evalResultOverride?: EvalResult;\n}\n\n/**\n * Safely convert a value to string, handling StructuredValue wrappers\n * WHY: Many code paths need to convert values to strings but must check\n *      for StructuredValue wrappers first to avoid producing [object Object]\n */\nfunction valueToString(value: unknown): string {\n  if (value === null) return ''; // Preserve legacy behaviour: null interpolates to empty\n  if (value === undefined) return 'undefined'; // Preserve 'undefined' string for display\n  if (typeof value === 'string') return value;\n  if (isStructuredValue(value)) return asText(value);\n  if (typeof value === 'object') return JSON.stringify(value);\n  return String(value);\n}\n\n/**\n * Create VariableSource metadata based on the value node type\n */\nfunction createVariableSource(valueNode: VarValue | undefined, directive: DirectiveNode): VariableSource {\n  const baseSource: VariableSource = {\n    directive: 'var',\n    syntax: 'quoted', // default\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n\n  // Handle primitive values (numbers, booleans, null)\n  if (typeof valueNode === 'number' || typeof valueNode === 'boolean' || valueNode === null) {\n    // For primitives, use the directive metadata to determine syntax\n    if (directive.meta?.primitiveType) {\n      baseSource.syntax = 'quoted'; // Primitives are treated like quoted values\n    }\n    return baseSource;\n  }\n  \n  // Determine syntax type based on AST node\n  if (valueNode.type === 'array') {\n    baseSource.syntax = 'array';\n    baseSource.wrapperType = 'brackets';\n  } else if (valueNode.type === 'object') {\n    baseSource.syntax = 'object';\n    baseSource.wrapperType = 'brackets';\n  } else if (valueNode.type === 'command') {\n    baseSource.syntax = 'command';\n    baseSource.wrapperType = 'brackets';\n  } else if (valueNode.type === 'code') {\n    baseSource.syntax = 'code';\n    baseSource.wrapperType = 'brackets';\n  } else if (valueNode.type === 'path') {\n    baseSource.syntax = 'path';\n    baseSource.wrapperType = 'brackets';\n  } else if (valueNode.type === 'section') {\n    baseSource.syntax = 'path'; // sections are path-based\n    baseSource.wrapperType = 'brackets';\n  } else if (valueNode.type === 'VariableReference') {\n    baseSource.syntax = 'reference';\n  } else if (directive.meta?.wrapperType) {\n    // Use wrapper type from directive metadata\n    baseSource.wrapperType = directive.meta.wrapperType;\n    if (directive.meta.wrapperType === 'singleQuote') {\n      baseSource.syntax = 'quoted';\n      baseSource.hasInterpolation = false;\n    } else if (directive.meta.wrapperType === 'doubleQuote' || directive.meta.wrapperType === 'backtick' || directive.meta.wrapperType === 'doubleColon') {\n      baseSource.syntax = 'template';\n      baseSource.hasInterpolation = true; // Assume interpolation for these types\n    } else if (directive.meta.wrapperType === 'tripleColon') {\n      baseSource.syntax = 'template';\n      baseSource.hasInterpolation = true; // Triple colon uses {{var}} interpolation\n    }\n  }\n\n  // Multi-line content is determined during evaluation, not from raw AST\n  // The isMultiLine property will be set based on the evaluated content\n\n  return baseSource;\n}\n\ntype DescriptorCollector = (descriptor?: SecurityDescriptor) => void;\n\nasync function interpolateAndCollect(\n  nodes: any,\n  env: Environment,\n  mergeDescriptor?: DescriptorCollector,\n  interpolationContext: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  if (!mergeDescriptor) {\n    return interpolate(nodes, env, interpolationContext);\n  }\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, interpolationContext, {\n    collectSecurityDescriptor: collected => {\n      if (collected) {\n        descriptors.push(collected);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1\n        ? descriptors[0]\n        : env.mergeSecurityDescriptors(...descriptors);\n    mergeDescriptor(merged);\n  }\n  return text;\n}\n\n/**\n * Evaluate @var directives.\n * This is the unified variable assignment directive that replaces @text and @data.\n * Type is inferred from the RHS syntax.\n */\nexport async function prepareVarAssignment(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<VarAssignmentResult> {\n  // Extract identifier from array\n  const identifierNodes = directive.values?.identifier as VariableNodeArray | undefined;\n  if (!identifierNodes || !Array.isArray(identifierNodes) || identifierNodes.length === 0) {\n    throw new Error('Var directive missing identifier');\n  }\n  \n  const identifierNode = identifierNodes[0];\n  if (!identifierNode || typeof identifierNode !== 'object' || !('identifier' in identifierNode)) {\n    throw new Error('Invalid identifier node structure');\n  }\n  const identifier = identifierNode.identifier;\n  if (!identifier || typeof identifier !== 'string') {\n    throw new Error('Var directive identifier must be a simple variable name');\n  }\n\n  const securityLabels = (directive.meta?.securityLabels ?? directive.values?.securityLabels) as DataLabel[] | undefined;\n  const baseDescriptor = makeSecurityDescriptor({ labels: securityLabels });\n  const capabilityKind = directive.kind as CapabilityKind;\n  const operationMetadata = {\n    kind: 'var',\n    identifier,\n    location: directive.location\n  };\n\n  let resolvedSecurityDescriptor: SecurityDescriptor | undefined;\n  const mergeResolvedDescriptor = (descriptor?: SecurityDescriptor): void => {\n    if (!descriptor) {\n      return;\n    }\n    resolvedSecurityDescriptor = resolvedSecurityDescriptor\n      ? env.mergeSecurityDescriptors(resolvedSecurityDescriptor, descriptor)\n      : descriptor;\n  };\n  const mergePipelineDescriptor = (\n    ...descriptors: (SecurityDescriptor | undefined)[]\n  ): SecurityDescriptor | undefined => {\n    const resolved = descriptors.filter(Boolean) as SecurityDescriptor[];\n    if (resolved.length === 0) {\n      return undefined;\n    }\n    if (resolved.length === 1) {\n      return resolved[0];\n    }\n    return env.mergeSecurityDescriptors(...resolved);\n  };\n  const descriptorFromVariable = (variable?: Variable): SecurityDescriptor | undefined => {\n    if (!variable?.mx) {\n      return undefined;\n    }\n    return varMxToSecurityDescriptor(variable.mx);\n  };\n  const interpolateWithSecurity = (\n    nodes: any,\n    interpolationContext: InterpolationContext = InterpolationContext.Default\n  ): Promise<string> => {\n    return interpolateAndCollect(nodes, env, mergeResolvedDescriptor, interpolationContext);\n  };\n\n  /**\n   * Extract security descriptor from a value (Variable, StructuredValue, or plain value)\n   */\n  const extractSecurityFromValue = (value: any): SecurityDescriptor | undefined => {\n    if (!value) return undefined;\n    // Check if it's a Variable with .mx\n    if (typeof value === 'object' && 'mx' in value && value.mx) {\n      const mx = value.mx;\n      const hasLabels = Array.isArray(mx.labels) && mx.labels.length > 0;\n      const hasTaint = Array.isArray(mx.taint) && mx.taint.length > 0;\n      if (hasLabels || hasTaint) {\n        return {\n          labels: mx.labels,\n          taint: mx.taint,\n          sources: mx.sources,\n          policyContext: mx.policy ?? undefined\n        } as SecurityDescriptor;\n      }\n    }\n    return undefined;\n  };\n\n  const finalizeVariable = (variable: Variable): Variable => {\n    const descriptor = resolvedSecurityDescriptor\n      ? env.mergeSecurityDescriptors(baseDescriptor, resolvedSecurityDescriptor)\n      : baseDescriptor;\n    const capabilityContext = createCapabilityContext({\n      kind: capabilityKind,\n      descriptor,\n      metadata: { identifier },\n      operation: operationMetadata\n    });\n    // Extract existing security from variable's mx\n    const existingSecurity = extractSecurityFromValue(variable);\n    const finalMetadata = VariableMetadataUtils.applySecurityMetadata(existingSecurity ? { security: existingSecurity } : undefined, {\n      existingDescriptor: descriptor,\n      capability: capabilityContext\n    });\n    // Update mx from the final security descriptor\n    if (!variable.mx) {\n      variable.mx = {};\n    }\n    if (finalMetadata.security) {\n      updateVarMxFromDescriptor(variable.mx, finalMetadata.security);\n    }\n    return VariableMetadataUtils.attachContext(variable);\n  };\n\n\n  // Get the value node - this contains type information from the parser\n  const valueNodes = directive.values?.value;\n  \n  // Debug: Log the value structure\n  if (process.env.MLLD_DEBUG === 'true') {\n    console.log(`\\n=== Processing @${identifier} ===`);\n    if (Array.isArray(valueNodes) && valueNodes.length > 0) {\n      console.log('  Value node type:', valueNodes[0].type);\n      console.log('  Has directive.values.withClause?', !!directive.values?.withClause);\n      console.log('  Has directive.meta.withClause?', !!directive.meta?.withClause);\n      if (directive.values?.withClause || directive.meta?.withClause) {\n        const wc = directive.values?.withClause || directive.meta?.withClause;\n        console.log('  Pipeline:', wc.pipeline?.map((p: any) => p.rawIdentifier).join(' | '));\n      }\n    }\n  }\n  if (!valueNodes || !Array.isArray(valueNodes) || valueNodes.length === 0) {\n    throw new Error('Var directive missing value');\n  }\n  \n  // For templates with multiple nodes (e.g., ::text {{var}}::), we need the whole array\n  const valueNode = valueNodes.length === 1 ? valueNodes[0] : valueNodes;\n\n  if (process.env.MLLD_DEBUG === 'true') {\n    console.error('[var.ts] Extracted valueNode:', {\n      identifier,\n      type: valueNode?.type,\n      isArray: Array.isArray(valueNode),\n      hasWithClause: !!(valueNode?.withClause),\n      hasPipeline: !!(valueNode?.withClause?.pipeline)\n    });\n  }\n\n  try {\n  // Type-based routing based on the AST structure\n  let resolvedValue: any;\n  const templateAst: any = null; // Store AST for templates that need lazy interpolation\n  \n  if (valueNode && typeof valueNode === 'object' && valueNode.type === 'FileReference') {\n    const { processContentLoader } = await import('./content-loader');\n    const { accessField } = await import('../utils/field-access');\n    const loadContentNode = {\n      type: 'load-content' as const,\n      source: valueNode.source,\n      options: valueNode.options,\n      pipes: valueNode.pipes\n    };\n    const rawResult = await processContentLoader(loadContentNode as any, env);\n    let structuredResult = isStructuredValue(rawResult) ? rawResult : wrapLoadContentValue(rawResult);\n    if (valueNode.fields && valueNode.fields.length > 0) {\n      for (const field of valueNode.fields) {\n        structuredResult = await accessField(structuredResult, field, { env });\n      }\n    }\n    resolvedValue = structuredResult;\n    \n  // Check for primitive values first (numbers, booleans, null)\n  } else if (typeof valueNode === 'number' || typeof valueNode === 'boolean' || valueNode === null) {\n    // Direct primitive values from the grammar\n    resolvedValue = valueNode;\n    \n  } else if (valueNode.type === 'Literal') {\n    // Handle literal nodes (booleans, numbers, strings)\n    resolvedValue = valueNode.value;\n    \n  } else if (valueNode.type === 'array') {\n    // Array literal: [1, 2, 3] or [,]\n    \n    // Check if this array has complex items that need lazy evaluation\n    const isComplex = hasComplexArrayItems(valueNode.items || valueNode.elements || []);\n    \n    if (isComplex) {\n      // For complex arrays, store the AST node for lazy evaluation\n      if (process.env.MLLD_DEBUG === 'true') {\n        logger.debug('var.ts: Storing complex array AST for lazy evaluation:', {\n          identifier,\n          valueNode\n        });\n      }\n      resolvedValue = valueNode;\n    } else {\n      // Process simple array items immediately\n      const processedItems = [];\n      for (const item of (valueNode.items || [])) {\n        if (item && typeof item === 'object') {\n          if ('content' in item && Array.isArray(item.content)) {\n            // This is wrapped content (like from a string literal)\n            const interpolated = await interpolateWithSecurity(item.content);\n            processedItems.push(interpolated);\n          } else if (item.type === 'Text' && 'content' in item) {\n            // Direct text content\n            processedItems.push(item.content);\n          } else if (typeof item === 'object' && item.type) {\n            // Other node types - evaluate them\n            const evaluated = await evaluateArrayItem(item, env, mergeResolvedDescriptor);\n            processedItems.push(evaluated);\n          } else {\n            // Primitive values\n            processedItems.push(item);\n          }\n        } else {\n          // Direct primitive value\n          processedItems.push(item);\n        }\n      }\n      resolvedValue = processedItems;\n    }\n    \n  } else if (valueNode.type === 'object') {\n    // Object literal: { \"key\": \"value\" }\n\n    // Check if this object has complex values that need lazy evaluation\n    const isComplex = hasComplexValues(valueNode.entries || valueNode.properties);\n    \n    if (isComplex) {\n      // For complex objects, store the AST node for lazy evaluation\n      resolvedValue = valueNode;\n    } else {\n      // Process simple object properties immediately\n      const processedObject: Record<string, any> = {};\n\n      // Handle entries format (new)\n      if (valueNode.entries) {\n        for (const entry of valueNode.entries) {\n          if (entry.type === 'pair') {\n            const key = entry.key;\n            const propValue = entry.value;\n          // Each property value might need interpolation\n          if (propValue && typeof propValue === 'object' && 'content' in propValue && Array.isArray(propValue.content)) {\n            // Handle wrapped string content (quotes, backticks, etc.)\n            processedObject[key] = await interpolateWithSecurity(propValue.content as any);\n          } else if (propValue && typeof propValue === 'object' && propValue.type === 'array') {\n            // Handle array values in objects\n            const processedArray = [];\n            \n            // Debug logging for Phase 2\n            if (identifier === 'complex' && key === 'users') {\n              logger.debug('Processing users array items:', {\n                itemCount: (propValue.items || []).length,\n                firstItem: propValue.items?.[0]\n              });\n            }\n            \n            for (const item of (propValue.items || [])) {\n              const evaluated = await evaluateArrayItem(item, env, mergeResolvedDescriptor);\n              processedArray.push(evaluated);\n            }\n            processedObject[key] = processedArray;\n          } else if (propValue && typeof propValue === 'object' && propValue.type === 'object') {\n            // Handle nested objects recursively\n            const nestedObj: Record<string, any> = {};\n            // Handle entries format\n            if (propValue.entries) {\n              for (const nestedEntry of propValue.entries) {\n                if (nestedEntry.type === 'pair') {\n                  nestedObj[nestedEntry.key] = await evaluateArrayItem(nestedEntry.value, env, mergeResolvedDescriptor);\n                }\n              }\n            }\n            // Handle properties format (legacy)\n            else if (propValue.properties) {\n              for (const [nestedKey, nestedValue] of Object.entries(propValue.properties)) {\n                nestedObj[nestedKey] = await evaluateArrayItem(nestedValue, env, mergeResolvedDescriptor);\n              }\n            }\n            processedObject[key] = nestedObj;\n          } else if (propValue && typeof propValue === 'object' && propValue.type) {\n            // Handle other node types (load-content, VariableReference, etc.)\n            processedObject[key] = await evaluateArrayItem(propValue, env, mergeResolvedDescriptor);\n          } else if (propValue && typeof propValue === 'object' && 'needsInterpolation' in propValue && Array.isArray(propValue.parts)) {\n            // Handle strings with @references that need interpolation\n            processedObject[key] = await interpolateWithSecurity(propValue.parts);\n          } else {\n            // For primitive types (numbers, booleans, null, strings), use as-is\n            processedObject[key] = propValue;\n          }\n          }\n          // Spread entries shouldn't be here (isComplex would be true)\n        }\n      }\n      // Handle properties format (legacy)\n      else if (valueNode.properties) {\n        for (const [key, propValue] of Object.entries(valueNode.properties)) {\n          // Each property value might need interpolation\n          if (propValue && typeof propValue === 'object' && 'content' in propValue && Array.isArray(propValue.content)) {\n            // Handle wrapped string content (quotes, backticks, etc.)\n            processedObject[key] = await interpolateWithSecurity(propValue.content as any);\n          } else if (propValue && typeof propValue === 'object' && propValue.type === 'array') {\n            // Handle array values in objects\n            const processedArray = [];\n            for (const item of (propValue.items || [])) {\n              const evaluated = await evaluateArrayItem(item, env, mergeResolvedDescriptor);\n              processedArray.push(evaluated);\n            }\n            processedObject[key] = processedArray;\n          } else if (propValue && typeof propValue === 'object' && propValue.type === 'object') {\n            // Handle nested objects recursively\n            const nestedObj: Record<string, any> = {};\n            const nestedData = propValue.entries || propValue.properties;\n            if (nestedData) {\n              if (propValue.entries) {\n                for (const nestedEntry of propValue.entries) {\n                  if (nestedEntry.type === 'pair') {\n                    nestedObj[nestedEntry.key] = await evaluateArrayItem(nestedEntry.value, env, mergeResolvedDescriptor);\n                  }\n                }\n              } else if (propValue.properties) {\n                for (const [nestedKey, nestedValue] of Object.entries(propValue.properties)) {\n                  nestedObj[nestedKey] = await evaluateArrayItem(nestedValue, env, mergeResolvedDescriptor);\n                }\n              }\n            }\n            processedObject[key] = nestedObj;\n          } else if (propValue && typeof propValue === 'object' && propValue.type) {\n            // Handle other node types (load-content, VariableReference, etc.)\n            processedObject[key] = await evaluateArrayItem(propValue, env, mergeResolvedDescriptor);\n          } else if (propValue && typeof propValue === 'object' && 'needsInterpolation' in propValue && Array.isArray((propValue as any).parts)) {\n            // Handle strings with @references that need interpolation\n            processedObject[key] = await interpolateWithSecurity((propValue as any).parts);\n          } else {\n            // For primitive types (numbers, booleans, null, strings), use as-is\n            processedObject[key] = propValue;\n          }\n        }\n      }\n      resolvedValue = processedObject;\n    }\n    \n  } else if (valueNode.type === 'section') {\n    // Section extraction: [file.md # Section]\n    const filePath = await interpolateWithSecurity(valueNode.path);\n    const sectionName = await interpolateWithSecurity(valueNode.section);\n    \n    // Read file and extract section\n    const fileContent = await env.readFile(filePath);\n    const { llmxmlInstance } = await import('../utils/llmxml-instance');\n    \n    try {\n      resolvedValue = await llmxmlInstance.getSection(fileContent, sectionName, {\n        includeNested: true,\n        includeTitle: true\n      });\n    } catch (error) {\n      // Fallback to basic extraction\n      resolvedValue = extractSection(fileContent, sectionName);\n    }\n    \n    // Check if we have an asSection modifier in the withClause\n    if (directive.values?.withClause?.asSection) {\n      const newHeader = await interpolateWithSecurity(directive.values.withClause.asSection);\n      resolvedValue = applyHeaderTransform(resolvedValue, newHeader);\n    }\n    \n  } else if (valueNode.type === 'load-content') {\n    // Content loader: <file.md> or <file.md # Section>\n    const { processContentLoader } = await import('./content-loader');\n    \n    // Pass the withClause to the content loader if it has asSection\n    if (directive.values?.withClause?.asSection) {\n      if (!valueNode.options) {\n        valueNode.options = {};\n      }\n\n      // Check if this is a glob pattern - use transform instead of section.renamed\n      const isGlob = valueNode.source?.raw?.includes('*') || valueNode.source?.raw?.includes('?');\n\n      if (isGlob) {\n        // For globs, use options.transform which content-loader expects for array transforms\n        valueNode.options.transform = {\n          type: 'template',\n          parts: directive.values.withClause.asSection\n        };\n      } else {\n        // For single files with sections, use options.section.renamed\n        if (!valueNode.options.section) {\n          valueNode.options.section = {};\n        }\n        valueNode.options.section.renamed = {\n          type: 'rename-template',\n          parts: directive.values.withClause.asSection\n        };\n      }\n    }\n    \n    resolvedValue = await processContentLoader(valueNode, env);\n    \n  } else if (valueNode.type === 'path') {\n    // Path dereference: [README.md]\n    const filePath = await interpolateWithSecurity(valueNode.segments);\n    resolvedValue = await env.readFile(filePath);\n    \n  } else if (valueNode.type === 'code') {\n    // Code execution: run js { ... } or js { ... }\n    const { evaluateCodeExecution } = await import('./code-execution');\n    const result = await evaluateCodeExecution(valueNode, env);\n    resolvedValue = result.value;\n    \n    // Infer variable type from result\n    \n  } else if (valueNode.type === 'command') {\n    // Shell command: run { ... }\n    // If a withClause is present on the /var directive (e.g., stdin/pipeline),\n    // delegate to evaluateRun so that stdin and pipelines are applied correctly.\n    const withClause = (directive.values?.withClause || directive.meta?.withClause) as any | undefined;\n    const hasWithClause = !!withClause;\n    let handledByRunEvaluator = false;\n\n    if (hasWithClause) {\n      const { evaluateRun } = await import('./run');\n      const runDirective: any = {\n        type: 'Directive',\n        nodeId: (directive as any).nodeId ? `${(directive as any).nodeId}-run` : undefined,\n        location: directive.location,\n        kind: 'run',\n        subtype: 'runCommand',\n        source: 'command',\n        values: {\n          command: valueNode.command,\n          withClause\n        },\n        raw: {\n          command: Array.isArray(valueNode.command)\n            ? (valueNode.meta?.raw || '')\n            : String(valueNode.command),\n          withClause\n        },\n        meta: {\n          // Mark as data value so evaluateRun does not emit document output\n          isDataValue: true\n        }\n      };\n      const result = await evaluateRun(runDirective, env);\n      resolvedValue = result.value;\n      handledByRunEvaluator = true;\n    } else {\n      // Regular command without withClause: execute directly\n      if (Array.isArray(valueNode.command)) {\n        // New: command is an array of AST nodes that need interpolation\n        const interpolatedCommand = await interpolateWithSecurity(\n          valueNode.command,\n          InterpolationContext.ShellCommand\n        );\n        resolvedValue = await env.executeCommand(interpolatedCommand);\n      } else {\n        // Legacy: command is a raw string (for backward compatibility)\n        resolvedValue = await env.executeCommand(valueNode.command);\n      }\n\n      // Apply automatic JSON parsing for shell command output\n      const { processCommandOutput } = await import('@interpreter/utils/json-auto-parser');\n      resolvedValue = processCommandOutput(resolvedValue);\n    }\n    \n  } else if (valueNode.type === 'VariableReference') {\n    // Variable reference: @otherVar\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log('Processing VariableReference in var.ts:', {\n        identifier,\n        varIdentifier: valueNode.identifier,\n        hasFields: !!(valueNode.fields && valueNode.fields.length > 0),\n        fields: valueNode.fields?.map(f => f.value)\n      });\n    }\n    \n    const sourceVar = env.getVariable(valueNode.identifier);\n    if (!sourceVar) {\n      const { MlldDirectiveError } = await import('@core/errors');\n      throw new MlldDirectiveError(\n        `Variable not found: ${valueNode.identifier}`,\n        'var',\n        { location: directive.location, env }\n      );\n    }\n    \n    // Copy the variable type from source - preserve Variables!\n    const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n    const { accessField } = await import('../utils/field-access');\n    \n    /**\n     * Preserve Variable wrapper when copying variable references\n     * WHY: Variable copies need to maintain metadata and type information\n     *      for proper Variable flow through the system\n     */\n    const resolvedVar = await resolveVariable(sourceVar, env, ResolutionContext.VariableCopy);\n    \n    // Handle field access if present\n    if (valueNode.fields && valueNode.fields.length > 0) {\n      // resolvedVar is already properly resolved with ResolutionContext.VariableCopy\n      // No need to extract again - field access will handle extraction if needed\n      \n      // Use enhanced field access to preserve context\n      const fieldResult = await accessField(resolvedVar, valueNode.fields[0], { \n        preserveContext: true,\n        env,\n        sourceLocation: directive.location\n      });\n      let currentResult = fieldResult as any;\n      \n      // Apply remaining fields if any\n      for (let i = 1; i < valueNode.fields.length; i++) {\n        currentResult = await accessField(currentResult.value, valueNode.fields[i], { \n          preserveContext: true, \n          parentPath: currentResult.accessPath,\n          env,\n          sourceLocation: directive.location\n        });\n      }\n      \n      resolvedValue = currentResult.value;\n      \n      // Check if the accessed field is an executable variable\n      if (resolvedValue && typeof resolvedValue === 'object' && \n          resolvedValue.type === 'executable') {\n        // Preserve the executable variable\n        const finalVar = finalizeVariable(resolvedValue);\n        return {\n          identifier,\n          variable: finalVar,\n          evalResultOverride: {\n            value: finalVar,\n            env,\n            stdout: '',\n            stderr: '',\n            exitCode: 0\n          }\n        };\n      }\n      \n      // IMPORTANT: When we have field access, the resolvedValue is the field value\n      // We should NOT fall through to the duplicate VariableReference handling below\n    } else {\n      // No field access - use the resolved Variable directly\n      resolvedValue = resolvedVar;\n    }\n    \n    // Apply condensed pipes if present (e.g., @var|@transform)\n    if (valueNode.pipes && valueNode.pipes.length > 0) {\n      // Use unified pipeline processor for condensed pipes\n      const { processPipeline } = await import('./pipeline/unified-processor');\n      \n      // Process through unified pipeline (handles condensed pipe conversion)\n      const result = await processPipeline({\n        value: resolvedValue,\n        env,\n        node: valueNode,\n        identifier,\n        location: directive.location,\n        descriptorHint: mergePipelineDescriptor(descriptorFromVariable(sourceVar), resolvedSecurityDescriptor)\n      });\n      \n      resolvedValue = result;\n    }\n    \n  } else if (Array.isArray(valueNode)) {\n    // For backtick templates, we should extract the text content directly\n    // Check if this is a simple text array (backtick template)\n    if (valueNode.length === 1 && valueNode[0].type === 'Text' && directive.meta?.wrapperType === 'backtick') {\n        resolvedValue = valueNode[0].content;\n    } else if (directive.meta?.wrapperType === 'doubleColon' || directive.meta?.wrapperType === 'tripleColon') {\n      // For double/triple colon templates, handle interpolation based on type\n      if (directive.meta?.wrapperType === 'tripleColon') {\n        // Triple colon uses {{var}} interpolation - store AST for lazy evaluation\n        resolvedValue = valueNode; // Store the AST array as the value\n        logger.debug('Storing template AST for triple-colon template', {\n          identifier,\n          ast: valueNode\n        });\n      } else {\n        // Double colon uses @var interpolation - interpolate now\n        resolvedValue = await interpolateWithSecurity(valueNode);\n      }\n    } else {\n      // Template or string content - need to interpolate\n        resolvedValue = await interpolateWithSecurity(valueNode);\n    }\n    \n  } else if (valueNode.type === 'Text' && 'content' in valueNode) {\n    // Simple text content\n    resolvedValue = valueNode.content;\n    \n  } else if (valueNode && (valueNode.type === 'foreach' || valueNode.type === 'foreach-command')) {\n    // Handle foreach expressions\n    const { evaluateForeachCommand } = await import('./foreach');\n    resolvedValue = await evaluateForeachCommand(valueNode, env);\n    \n  } else if (valueNode && valueNode.type === 'WhenExpression') {\n    // Handle when expressions\n    const { evaluateWhenExpression } = await import('./when-expression');\n    const whenResult = await evaluateWhenExpression(valueNode as any, env);\n    resolvedValue = whenResult.value;\n    \n  } else if (valueNode && valueNode.type === 'ExeBlock') {\n    const { evaluateExeBlock } = await import('./exe');\n    const blockEnv = env.createChild();\n    const blockResult = await evaluateExeBlock(valueNode as any, blockEnv);\n    resolvedValue = blockResult.value;\n\n  } else if (valueNode && valueNode.type === 'ExecInvocation') {\n    // Handle exec function invocations: @getConfig(), @transform(@data)\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.error('[var.ts] Processing ExecInvocation:', {\n        hasWithClause: !!valueNode.withClause,\n        hasPipeline: !!(valueNode.withClause?.pipeline)\n      });\n    }\n    const { evaluateExecInvocation } = await import('./exec-invocation');\n    const result = await evaluateExecInvocation(valueNode, env);\n    resolvedValue = result.value;\n    \n    // Infer variable type from result\n    \n  } else if (valueNode && valueNode.type === 'VariableReferenceWithTail') {\n    // Variable with tail modifiers (e.g., @var @result = @data with { pipeline: [@transform] })\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log('Processing VariableReferenceWithTail in var.ts');\n    }\n    const varWithTail = valueNode;\n    const sourceVar = env.getVariable(varWithTail.variable.identifier);\n    if (!sourceVar) {\n      const { MlldDirectiveError } = await import('@core/errors');\n      throw new MlldDirectiveError(\n        `Variable not found: ${varWithTail.variable.identifier}`,\n        'var',\n        { location: directive.location, env }\n      );\n    }\n    \n    // Get the base value - preserve Variable for field access\n    const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n    const { accessFields } = await import('../utils/field-access');\n    \n    // Determine appropriate context based on what operations will be performed\n    const needsPipelineExtraction = varWithTail.withClause && varWithTail.withClause.pipeline;\n    const hasFieldAccess = varWithTail.variable.fields && varWithTail.variable.fields.length > 0;\n    \n    // Use appropriate resolution context\n    const context = needsPipelineExtraction && !hasFieldAccess \n      ? ResolutionContext.PipelineInput \n      : ResolutionContext.FieldAccess;\n    \n    const resolvedVar = await resolveVariable(sourceVar, env, context);\n    let result = resolvedVar;\n    \n    // Apply field access if present\n    if (varWithTail.variable.fields && varWithTail.variable.fields.length > 0) {\n      // Use enhanced field access to track context\n      const fieldResult = await accessFields(resolvedVar, varWithTail.variable.fields, { \n        preserveContext: true,\n        env,\n        sourceLocation: directive.location\n      });\n      result = (fieldResult as any).value;\n    }\n    \n    // Apply pipeline if present\n    if (varWithTail.withClause && varWithTail.withClause.pipeline) {\n      const { processPipeline } = await import('./pipeline/unified-processor');\n      \n      // Process through unified pipeline\n      result = await processPipeline({\n        value: result,\n        env,\n        node: varWithTail,\n        identifier: varWithTail.identifier,\n        location: directive.location,\n        descriptorHint: mergePipelineDescriptor(descriptorFromVariable(sourceVar), resolvedSecurityDescriptor)\n      });\n    }\n    \n    resolvedValue = result;\n    \n  } else if (valueNode && (valueNode.type === 'BinaryExpression' || valueNode.type === 'TernaryExpression' || valueNode.type === 'UnaryExpression')) {\n    // Handle expression nodes\n    const { evaluateUnifiedExpression } = await import('./expressions');\n    const result = await evaluateUnifiedExpression(valueNode, env);\n    resolvedValue = result.value;\n    \n  } else if (valueNode && valueNode.type === 'ForExpression') {\n    // Handle for expressions: for @item in @collection => expression\n    \n    // Import and evaluate the for expression\n    const { evaluateForExpression } = await import('./for');\n    const forResult = await evaluateForExpression(valueNode, env);\n    \n    // The result is already an ArrayVariable\n    const finalVar = finalizeVariable(forResult);\n    return {\n      identifier,\n      variable: finalVar,\n      evalResultOverride: { value: finalVar, env }\n    };\n    \n  } else {\n    // Default case - try to interpolate as text\n    if (process.env.MLLD_DEBUG === 'true') {\n      logger.debug('var.ts: Default case for valueNode:', { valueNode });\n    }\n    resolvedValue = await interpolateWithSecurity([valueNode]);\n  }\n\n  const resolvedValueDescriptor = extractSecurityDescriptor(resolvedValue, {\n    recursive: true,\n    mergeArrayElements: true\n  });\n  mergeResolvedDescriptor(resolvedValueDescriptor);\n\n  // Create and store the appropriate variable type\n  const location = astLocationToSourceLocation(directive.location, env.getCurrentFilePath());\n  const source = createVariableSource(valueNode, directive);\n  const baseCtx: Partial<VariableContext> = { definedAt: location };\n  const baseInternal: Partial<VariableInternalMetadata> = {};\n\n  const cloneFactoryOptions = (\n    overrides?: Partial<VariableFactoryInitOptions>\n  ): VariableFactoryInitOptions => ({\n    mx: { ...baseCtx, ...(overrides?.mx ?? {}) },\n    internal: { ...baseInternal, ...(overrides?.internal ?? {}) }\n  });\n\n  const applySecurityOptions = (\n    overrides?: Partial<VariableFactoryInitOptions>,\n    existing?: SecurityDescriptor\n  ): VariableFactoryInitOptions => {\n    const options = cloneFactoryOptions(overrides);\n    // Apply security metadata (still uses legacy metadata internally)\n    const finalMetadata = VariableMetadataUtils.applySecurityMetadata(undefined, {\n      labels: securityLabels,\n      existingDescriptor: existing ?? resolvedValueDescriptor\n    });\n    // Update mx from security descriptor\n    if (finalMetadata?.security) {\n      updateVarMxFromDescriptor(options.mx ?? (options.mx = {}), finalMetadata.security);\n    }\n    if (finalMetadata) {\n      options.metadata = {\n        ...(options.metadata ?? {}),\n        ...finalMetadata\n      };\n    }\n    return options;\n  };\n  \n  // Mark if value came from a function for pipeline retryability\n  if (valueNode && (\n    valueNode.type === 'ExecInvocation' || \n    valueNode.type === 'command' || \n    valueNode.type === 'code'\n  )) {\n    baseInternal.isRetryable = true;\n    baseInternal.sourceFunction = valueNode; // Store the AST node for re-execution\n  }\n\n  let variable: Variable;\n\n  if (process.env.MLLD_DEBUG === 'true') {\n    console.log('Creating variable:', {\n      identifier,\n      valueNodeType: valueNode?.type,\n      resolvedValue,\n      resolvedValueType: typeof resolvedValue\n    });\n  }\n  if (process.env.MLLD_DEBUG_IDS === 'true' && (identifier === 'squared' || identifier === 'ids')) {\n    try {\n      const structuredInfo = isStructuredValue(resolvedValue)\n        ? {\n            type: resolvedValue.type,\n            text: resolvedValue.text,\n            dataType: typeof resolvedValue.data,\n            preview: resolvedValue.data && typeof resolvedValue.data === 'object'\n              ? Array.isArray(resolvedValue.data)\n                ? { length: resolvedValue.data.length, first: resolvedValue.data[0] }\n                : { keys: Object.keys(resolvedValue.data).slice(0, 5) }\n              : resolvedValue.data\n          }\n        : undefined;\n      console.error('[var-debug]', {\n        identifier,\n        resolvedType: typeof resolvedValue,\n        isStructured: isStructuredValue(resolvedValue),\n        structuredInfo,\n        rawValue: resolvedValue\n      });\n    } catch {}\n  }\n\n  // Check if resolvedValue is already a Variable that we should preserve\n  const { isVariable } = await import('../utils/variable-resolution');\n  if (isVariable(resolvedValue)) {\n    // Preserve the existing Variable (e.g., when copying an executable)\n    // Update its name and metadata to reflect the new assignment\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log('Preserving existing Variable:', {\n        identifier,\n        resolvedValueType: resolvedValue.type,\n        resolvedValueName: resolvedValue.name\n      });\n    }\n    const overrides: Partial<VariableFactoryInitOptions> = {\n      mx: { ...(resolvedValue.mx ?? {}), ...baseCtx },\n      internal: { ...(resolvedValue.internal ?? {}), ...baseInternal }\n    };\n    // Preserve security from existing variable\n    const existingSecurity = extractSecurityFromValue(resolvedValue);\n    const options = applySecurityOptions(overrides, existingSecurity);\n    variable = {\n      ...resolvedValue,\n      name: identifier,\n      definedAt: location,\n      mx: options.mx,\n      internal: options.internal\n    };\n    VariableMetadataUtils.attachContext(variable);\n  } else if (isStructuredValue(resolvedValue)) {\n    const options = applySecurityOptions(\n      {\n        internal: {\n          isStructuredValue: true,\n          structuredValueType: resolvedValue.type\n        }\n      },\n      resolvedValueDescriptor\n    );\n    variable = createStructuredValueVariable(identifier, resolvedValue, source, options);\n\n  } else if (typeof valueNode === 'number' || typeof valueNode === 'boolean' || valueNode === null) {\n    // Direct primitive values - we need to preserve their types\n    const options = applySecurityOptions();\n    variable = createPrimitiveVariable(\n      identifier,\n      valueNode, // Use the actual primitive value\n      source,\n      options\n    );\n\n  } else if (valueNode.type === 'array') {\n    const isComplex = hasComplexArrayItems(valueNode.items || valueNode.elements || []);\n    \n    // Debug logging\n    if (process.env.MLLD_DEBUG === 'true') {\n      logger.debug('var.ts: Creating array variable:', {\n        identifier,\n        isComplex,\n        resolvedValueType: typeof resolvedValue,\n        resolvedValueIsArray: Array.isArray(resolvedValue),\n        resolvedValue\n      });\n    }\n    \n    const options = applySecurityOptions();\n    variable = createArrayVariable(identifier, resolvedValue, isComplex, source, options);\n    \n  } else if (valueNode.type === 'object') {\n    const isComplex = hasComplexValues(valueNode.entries || valueNode.properties);\n    const options = applySecurityOptions();\n    variable = createObjectVariable(identifier, resolvedValue, isComplex, source, options);\n    \n  } else if (valueNode.type === 'command') {\n    const options = applySecurityOptions();\n    variable = createCommandResultVariable(identifier, resolvedValue, valueNode.command, source, \n      undefined, undefined, options);\n    \n  } else if (valueNode.type === 'code') {\n    // Need to get source code from the value node\n    const sourceCode = valueNode.code || ''; // TODO: Verify how to extract source code\n    const options = applySecurityOptions();\n    variable = createComputedVariable(identifier, resolvedValue, \n      valueNode.language || 'js', sourceCode, source, options);\n    \n  } else if (valueNode.type === 'path') {\n    const filePath = await interpolateWithSecurity(valueNode.segments);\n    const options = applySecurityOptions();\n    variable = createFileContentVariable(identifier, resolvedValue, filePath, source, options);\n    \n  } else if (valueNode.type === 'section') {\n    const filePath = await interpolateWithSecurity(valueNode.path);\n    const sectionName = await interpolateWithSecurity(valueNode.section);\n    const options = applySecurityOptions();\n    variable = createSectionContentVariable(identifier, resolvedValue, filePath, \n      sectionName, 'hash', source, options);\n    \n  } else if (valueNode.type === 'VariableReference') {\n    // For VariableReference nodes, create variable based on resolved value type\n    // This handles cases like @user.name where resolvedValue is the field value\n    const actualValue = isStructuredValue(resolvedValue) ? asData(resolvedValue) : resolvedValue;\n    const existingSecurity = extractSecurityFromValue(resolvedValue);\n    if (typeof actualValue === 'string') {\n      const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n      variable = createSimpleTextVariable(identifier, actualValue, source, options);\n    } else if (typeof actualValue === 'number' || typeof actualValue === 'boolean' || actualValue === null) {\n      const options = applySecurityOptions(undefined, existingSecurity);\n      variable = createPrimitiveVariable(identifier, actualValue, source, options);\n    } else if (Array.isArray(actualValue)) {\n      const options = applySecurityOptions(undefined, existingSecurity);\n      variable = createArrayVariable(identifier, actualValue, false, source, options);\n    } else if (typeof actualValue === 'object' && actualValue !== null) {\n      const options = applySecurityOptions(undefined, existingSecurity);\n      variable = createObjectVariable(identifier, actualValue, false, source, options);\n    } else {\n      // Fallback to text\n      const options = applySecurityOptions(undefined, existingSecurity);\n      variable = createSimpleTextVariable(identifier, valueToString(resolvedValue), source, options);\n    }\n    \n  } else if (valueNode.type === 'load-content') {\n    const structuredValue = wrapLoadContentValue(resolvedValue);\n    const options = applySecurityOptions({\n      internal: {\n        structuredValueMetadata: structuredValue.metadata\n      }\n    });\n    variable = createStructuredValueVariable(identifier, structuredValue, source, options);\n    resolvedValue = structuredValue;\n\n  } else if (valueNode.type === 'foreach' || valueNode.type === 'foreach-command') {\n    // Foreach expressions always return arrays\n    const isComplex = false; // foreach results are typically simple values\n    const options = applySecurityOptions();\n    variable = createArrayVariable(identifier, resolvedValue, isComplex, source, options);\n\n  } else if (valueNode.type === 'WhenExpression') {\n    // When expressions can return any type based on matching arm\n    if (isStructuredValue(resolvedValue)) {\n      const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n      variable = createStructuredValueVariable(identifier, resolvedValue, source, options);\n    } else if (typeof resolvedValue === 'object' && resolvedValue !== null) {\n      if (Array.isArray(resolvedValue)) {\n        const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n        variable = createArrayVariable(identifier, resolvedValue, false, source, options);\n      } else {\n        const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n        variable = createObjectVariable(identifier, resolvedValue as Record<string, unknown>, false, source, options);\n      }\n    } else if (typeof resolvedValue === 'boolean' || typeof resolvedValue === 'number' || resolvedValue === null) {\n      const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n      variable = createPrimitiveVariable(identifier, resolvedValue, source, options);\n    } else {\n      const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n      variable = createSimpleTextVariable(identifier, valueToString(resolvedValue), source, options);\n    }\n\n  } else if (valueNode.type === 'ExecInvocation' || valueNode.type === 'ExeBlock') {\n    // Exec invocations and blocks can return any type\n    if (isStructuredValue(resolvedValue)) {\n      const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n      variable = createStructuredValueVariable(identifier, resolvedValue, source, options);\n    } else if (typeof resolvedValue === 'object' && resolvedValue !== null) {\n      if (Array.isArray(resolvedValue)) {\n        const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n        variable = createArrayVariable(identifier, resolvedValue, false, source, options);\n      } else {\n        const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n        variable = createObjectVariable(identifier, resolvedValue as Record<string, unknown>, false, source, options);\n      }\n    } else {\n      const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n      variable = createSimpleTextVariable(identifier, valueToString(resolvedValue), source, options);\n    }\n\n  } else if (valueNode.type === 'VariableReferenceWithTail') {\n    // Variable with tail modifiers - create based on resolved type\n    const actualValue = isStructuredValue(resolvedValue) ? asData(resolvedValue) : resolvedValue;\n    if (typeof actualValue === 'object' && actualValue !== null) {\n      if (Array.isArray(actualValue)) {\n        const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n        variable = createArrayVariable(identifier, actualValue, false, source, options);\n      } else {\n        const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n        variable = createObjectVariable(identifier, actualValue, false, source, options);\n      }\n    } else {\n      const options = applySecurityOptions(undefined, resolvedValueDescriptor);\n      variable = createSimpleTextVariable(identifier, valueToString(resolvedValue), source, options);\n    }\n    \n  } else if (directive.meta?.expressionType) {\n    // Expression results - create primitive variables for boolean/number results\n    if (typeof resolvedValue === 'boolean' || typeof resolvedValue === 'number' || resolvedValue === null) {\n      const options = applySecurityOptions();\n      variable = createPrimitiveVariable(identifier, resolvedValue, source, options);\n    } else {\n      // Expression returned non-primitive (e.g., string comparison)\n      const options = applySecurityOptions();\n      variable = createSimpleTextVariable(identifier, valueToString(resolvedValue), source, options);\n    }\n    \n  } else if (valueNode.type === 'Literal') {\n    // Literal nodes - DON'T create variable yet, let it fall through to pipeline processing\n    // The variable will be created after checking for pipelines\n\n  } else {\n    // Text variables - need to determine specific type\n    const strValue = valueToString(resolvedValue);\n    \n    if (directive.meta?.wrapperType === 'singleQuote') {\n      const options = applySecurityOptions();\n      variable = createSimpleTextVariable(identifier, strValue, source, options);\n    } else if (directive.meta?.isTemplateContent || directive.meta?.wrapperType === 'backtick' || directive.meta?.wrapperType === 'doubleQuote' || directive.meta?.wrapperType === 'doubleColon' || directive.meta?.wrapperType === 'tripleColon') {\n      // Template variable\n      let templateType: 'backtick' | 'doubleColon' | 'tripleColon' = 'backtick';\n      if (directive.meta?.wrapperType === 'doubleColon') {\n        templateType = 'doubleColon';\n      } else if (directive.meta?.wrapperType === 'tripleColon') {\n        templateType = 'tripleColon';\n      }\n      \n      // For triple-colon templates, the value is the AST array, not a string\n      const templateValue = directive.meta?.wrapperType === 'tripleColon' && Array.isArray(resolvedValue) \n        ? resolvedValue as any // Pass the AST array\n        : strValue; // For other templates, use the string value\n      const options = applySecurityOptions();\n      variable = createTemplateVariable(\n        identifier,\n        templateValue,\n        undefined,\n        templateType as any,\n        source,\n        options\n      );\n    } else if (directive.meta?.wrapperType === 'doubleQuote' || source.hasInterpolation) {\n      // Interpolated text - need to track interpolation points\n      // For now, create without interpolation points - TODO: extract these from AST\n      const options = applySecurityOptions();\n      variable = createInterpolatedTextVariable(identifier, strValue, [], source, options);\n    } else {\n      // Default to simple text\n      const options = applySecurityOptions();\n      variable = createSimpleTextVariable(identifier, strValue, source, options);\n    }\n  }\n\n  // Use unified pipeline processor\n  const { processPipeline } = await import('./pipeline/unified-processor');\n  \n  // Create variable if not already created (for Literal nodes)\n  if (!variable) {\n    if (valueNode && valueNode.type === 'Literal') {\n      if (typeof resolvedValue === 'boolean' || typeof resolvedValue === 'number' || resolvedValue === null) {\n        const options = applySecurityOptions();\n        variable = createPrimitiveVariable(identifier, resolvedValue, source, options);\n      } else {\n        const options = applySecurityOptions();\n        variable = createSimpleTextVariable(identifier, valueToString(resolvedValue), source, options);\n      }\n    } else {\n      const options = applySecurityOptions();\n      variable = createSimpleTextVariable(identifier, valueToString(resolvedValue), source, options);\n    }\n  }\n  \n  // Skip pipeline processing if:\n  // 1. This is an ExecInvocation with a withClause (already processed by evaluateExecInvocation)\n  // 2. This is a VariableReference with pipes (already processed above around line 406)\n  // 3. This is a load-content node with pipes (already processed by content-loader)\n  let result = variable;\n  const skipPipeline = (valueNode && valueNode.type === 'ExecInvocation' && valueNode.withClause) ||\n                       (valueNode && valueNode.type === 'VariableReference' && valueNode.pipes) ||\n                       (valueNode && valueNode.type === 'load-content' && valueNode.pipes);\n  // If the command was executed via evaluateRun (stdin/pipeline already applied),\n  // do not run pipeline processing again.\n  const handledByRun = (valueNode && valueNode.type === 'command')\n    && !!(directive.values?.withClause || directive.meta?.withClause);\n  \n  if (!skipPipeline && !handledByRun) {\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.error('[var.ts] Calling processPipeline:', {\n        identifier,\n        variableType: variable.type,\n        hasCtx: !!variable.mx,\n        hasInternal: !!variable.internal,\n        isRetryable: variable.internal?.isRetryable || false,\n        hasSourceFunction: !!(variable.internal?.sourceFunction),\n        sourceNodeType: (variable.internal?.sourceFunction as any)?.type\n      });\n    }\n    // Process through unified pipeline (handles detection, validation, execution)\n    result = await processPipeline({\n      value: variable,\n      env,\n      node: valueNode,\n      directive,\n      identifier,\n      location: directive.location,\n      isRetryable: variable.internal?.isRetryable || false\n    });\n  }\n  \n  // If pipeline was executed, result will be a string\n  // Create new variable with the result\n    if (typeof result === 'string' && result !== variable.value) {\n      const existingSecurity = extractSecurityFromValue(variable);\n      const options = applySecurityOptions(\n        {\n          mx: { ...(variable.mx ?? {}), ...baseCtx },\n          internal: { ...(variable.internal ?? {}), ...baseInternal }\n        },\n        existingSecurity\n      );\n    variable = createSimpleTextVariable(identifier, result, source, options);\n  } else if (isStructuredValue(result)) {\n    const existingSecurity = extractSecurityFromValue(variable);\n    const options = applySecurityOptions(\n      {\n        mx: { ...(variable.mx ?? {}), ...baseCtx },\n        internal: { ...(variable.internal ?? {}), ...baseInternal, isPipelineResult: true }\n      },\n      existingSecurity\n    );\n    variable = createStructuredValueVariable(identifier, result, source, options);\n  }\n  \n  const finalVar = finalizeVariable(variable);\n  \n  // Debug logging for primitive values\n  if (process.env.MLLD_DEBUG === 'true' && identifier === 'sum') {\n    logger.debug('Setting variable @sum:', {\n      identifier,\n      resolvedValue,\n      valueType: typeof resolvedValue,\n      variableType: finalVar.type,\n      variableValue: finalVar.value\n    });\n  }\n\n  return { identifier, variable: finalVar };\n  } catch (error) {\n    throw error;\n  }\n}\n\nexport async function evaluateVar(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<EvalResult> {\n  const assignment =\n    context?.precomputedVarAssignment ?? (await prepareVarAssignment(directive, env));\n  env.setVariable(assignment.identifier, assignment.variable);\n  return assignment.evalResultOverride ?? { value: '', env };\n}\n\n/**\n * Check if an object has complex values that need lazy evaluation\n */\nfunction hasComplexValues(objOrProperties: any): boolean {\n  if (!objOrProperties) return false;\n\n  // Handle entries format (new)\n  if (Array.isArray(objOrProperties)) {\n    for (const entry of objOrProperties) {\n      if (entry.type === 'spread') {\n        // Spreads always need lazy evaluation\n        return true;\n      }\n      if (entry.type === 'pair') {\n        const value = entry.value;\n        if (value && typeof value === 'object') {\n          if ('type' in value && (\n            value.type === 'code' ||\n            value.type === 'command' ||\n            value.type === 'VariableReference' ||\n            value.type === 'path' ||\n            value.type === 'section' ||\n            value.type === 'runExec' ||\n            value.type === 'ExecInvocation' ||\n            value.type === 'load-content'\n          )) {\n            return true;\n          }\n          // Check if it's a nested object with complex values\n          if (value.type === 'object') {\n            const nestedData = value.entries || value.properties;\n            if (nestedData && hasComplexValues(nestedData)) {\n              return true;\n            }\n          }\n          // Check if it's an array with complex items\n          if (value.type === 'array' && hasComplexArrayItems(value.items || value.elements || [])) {\n            return true;\n          }\n          // Check plain objects (without type field) recursively\n          if (!value.type && typeof value === 'object' && !Array.isArray(value)) {\n            if (hasComplexValues(value)) {\n              return true;\n            }\n          }\n        }\n      }\n    }\n    return false;\n  }\n\n  // Handle properties format (legacy) - it's a Record<string, any>\n  for (const value of Object.values(objOrProperties)) {\n    if (value && typeof value === 'object') {\n      if ('type' in value && (\n        value.type === 'code' ||\n        value.type === 'command' ||\n        value.type === 'VariableReference' ||\n        value.type === 'path' ||\n        value.type === 'section' ||\n        value.type === 'runExec' ||\n        value.type === 'ExecInvocation' ||\n        value.type === 'load-content'\n      )) {\n        return true;\n      }\n      // Check if it's a nested object with complex values\n      if (value.type === 'object') {\n        const nestedData = value.entries || value.properties;\n        if (nestedData && hasComplexValues(nestedData)) {\n          return true;\n        }\n      }\n      // Check if it's an array with complex items\n      if (value.type === 'array' && hasComplexArrayItems(value.items || value.elements || [])) {\n        return true;\n      }\n      // Check plain objects (without type field) recursively\n      if (!value.type && typeof value === 'object' && !Array.isArray(value)) {\n        if (hasComplexValues(value)) {\n          return true;\n        }\n      }\n    }\n  }\n\n  return false;\n}\n\n/**\n * Check if array items contain complex values\n */\nfunction hasComplexArrayItems(items: any[]): boolean {\n  if (!items || !Array.isArray(items) || items.length === 0) return false;\n  \n  for (const item of items) {\n    if (item && typeof item === 'object') {\n      if ('type' in item && (\n        item.type === 'code' || \n        item.type === 'command' || \n        item.type === 'VariableReference' ||\n        item.type === 'array' ||\n        item.type === 'object' ||\n        item.type === 'path' ||\n        item.type === 'section' ||\n        item.type === 'load-content' ||\n        item.type === 'ExecInvocation'\n      )) {\n        return true;\n      }\n      // Check nested arrays and objects\n      if (Array.isArray(item) && hasComplexArrayItems(item)) {\n        return true;\n      }\n      if (item.constructor === Object && hasComplexValues(item)) {\n        return true;\n      }\n    }\n  }\n  \n  return false;\n}\n\n/**\n * Evaluate an array item based on its type\n * This function evaluates items that will be stored in arrays, preserving Variables\n * instead of extracting their values immediately.\n */\nasync function evaluateArrayItem(\n  item: any,\n  env: Environment,\n  collectDescriptor?: DescriptorCollector\n): Promise<any> {\n  if (!item || typeof item !== 'object') {\n    return item;\n  }\n\n  // Debug logging for Phase 2\n  if (process.env.MLLD_DEBUG === 'true' && item.type === 'object') {\n    logger.debug('evaluateArrayItem processing object:', {\n      hasProperties: !!item.properties,\n      propertyKeys: item.properties ? Object.keys(item.properties) : [],\n      sampleProperty: item.properties?.name\n    });\n  }\n\n  // Handle wrapped content first (e.g., quoted strings in arrays)\n  // This includes strings in objects: {\"name\": \"alice\"} where \"alice\" becomes\n  // {content: [{type: 'Text', content: 'alice'}], wrapperType: 'doubleQuote'}\n  if ('content' in item && Array.isArray(item.content) && 'wrapperType' in item) {\n    const hasOnlyLiteralsOrText = item.content.every(\n      (node: any) =>\n        node &&\n        typeof node === 'object' &&\n        ((node.type === 'Literal' && 'value' in node) || (node.type === 'Text' && 'content' in node))\n    );\n    if (hasOnlyLiteralsOrText) {\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        console.error('[evaluateArrayItem] literal/text wrapper', {\n          wrapperType: item.wrapperType,\n          items: item.content.map((node: any) => node.type)\n        });\n      }\n      const joined = item.content\n        .map((node: any) => (node.type === 'Literal' ? node.value : node.content))\n        .join('');\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        try {\n          fs.appendFileSync(\n            '/tmp/mlld-debug.log',\n            JSON.stringify({\n              source: 'evaluateArrayItem',\n              wrapperType: item.wrapperType,\n              joined\n            }) + '\\n'\n          );\n        } catch {}\n      }\n      return joined;\n    }\n    if (process.env.MLLD_DEBUG_FIX === 'true') {\n      console.error('[evaluateArrayItem] interpolating wrapper', {\n        wrapperType: item.wrapperType,\n        itemTypes: item.content.map((node: any) => node?.type)\n      });\n    }\n    return await interpolateAndCollect(item.content, env, collectDescriptor);\n  }\n\n  // Also handle the case where we just have content array without wrapperType\n  if ('content' in item && Array.isArray(item.content)) {\n    return await interpolateAndCollect(item.content, env, collectDescriptor);\n  }\n  \n  // Handle raw Text nodes that may appear in objects\n  if (item.type === 'Text' && 'content' in item) {\n    return item.content;\n  }\n\n  // Handle Literal nodes from grammar (numbers, booleans, null)\n  if (item.type === 'Literal' && 'value' in item) {\n    return item.value;\n  }\n\n  // Handle needsInterpolation marker (from DataString with @references)\n  if ('needsInterpolation' in item && Array.isArray(item.parts)) {\n    return await interpolateAndCollect(item.parts, env, collectDescriptor);\n  }\n\n  // Handle objects without explicit type property (plain objects from parser)\n  if (!item.type && typeof item === 'object' && item.constructor === Object) {\n    const nestedObj: Record<string, any> = {};\n    for (const [key, value] of Object.entries(item)) {\n      // Skip internal properties\n      if (key === 'wrapperType' || key === 'nodeId' || key === 'location') {\n        continue;\n      }\n      nestedObj[key] = await evaluateArrayItem(value, env, collectDescriptor);\n    }\n    return nestedObj;\n  }\n\n  switch (item.type) {\n    case 'WhenExpression':\n      // Evaluate when-expression inside arrays/objects\n      {\n        const { evaluateWhenExpression } = await import('./when-expression');\n        const res = await evaluateWhenExpression(item as any, env);\n        return res.value as any;\n      }\n    case 'array':\n      // Nested array\n      const nestedItems = [];\n      for (const nestedItem of (item.items || [])) {\n        nestedItems.push(await evaluateArrayItem(nestedItem, env, collectDescriptor));\n      }\n      return nestedItems;\n\n    case 'object':\n      // Object in array\n      const processedObject: Record<string, any> = {};\n      // Handle entries format (new)\n      if (item.entries) {\n        for (const entry of item.entries) {\n          if (entry.type === 'pair') {\n            processedObject[entry.key] = await evaluateArrayItem(entry.value, env, collectDescriptor);\n          }\n          // Spreads shouldn't be in simple objects (isComplex would be true)\n        }\n      }\n      // Handle properties format (legacy)\n      else if (item.properties) {\n        for (const [key, propValue] of Object.entries(item.properties)) {\n          processedObject[key] = await evaluateArrayItem(propValue, env, collectDescriptor);\n        }\n      }\n      return processedObject;\n\n    case 'VariableReference':\n      // Variable reference in array - PRESERVE THE VARIABLE!\n      const variable = env.getVariable(item.identifier);\n      if (!variable) {\n        throw new Error(`Variable not found: ${item.identifier}`);\n      }\n      \n      /**\n       * Preserve Variable wrapper when storing in array elements\n       * WHY: Array elements should maintain Variable metadata to enable proper\n       *      Variable flow through data structures\n       */\n      const { resolveVariable, ResolutionContext } = await import('@interpreter/utils/variable-resolution');\n      return await resolveVariable(variable, env, ResolutionContext.ArrayElement);\n\n    case 'path':\n      // Path node in array - read the file content\n      const filePath = await interpolateAndCollect(item.segments || [item], env, collectDescriptor);\n      const fileContent = await env.readFile(filePath);\n      return fileContent;\n\n    case 'SectionExtraction':\n      // Section extraction in array\n      const sectionName = await interpolateAndCollect(item.section, env, collectDescriptor);\n      const sectionFilePath = await interpolateAndCollect(\n        item.path.segments || [item.path],\n        env,\n        collectDescriptor\n      );\n      const sectionFileContent = await env.readFile(sectionFilePath);\n      \n      // Use standard section extraction\n      const { extractSection } = await import('./show');\n      return extractSection(sectionFileContent, sectionName);\n\n    case 'load-content':\n      // Load content node in array - use the content loader\n      const { processContentLoader } = await import('./content-loader');\n      const loadResult = await processContentLoader(item, env);\n\n      // Handle file-loaded values (both StructuredValue and LoadContentResult formats)\n      const { isFileLoadedValue } = await import('@interpreter/utils/load-content-structured');\n      if (isFileLoadedValue(loadResult)) {\n        // Return structured format if already wrapped, otherwise extract content\n        return isStructuredValue(loadResult) ? loadResult : loadResult.content;\n      }\n\n      return loadResult;\n\n    default:\n      // Handle plain objects without type property\n      if (!item.type && typeof item === 'object' && item.constructor === Object) {\n        // This is a plain object with properties that might have wrapped content\n        const plainObj: Record<string, any> = {};\n        for (const [key, value] of Object.entries(item)) {\n          // Skip internal properties\n          if (key === 'wrapperType' || key === 'nodeId' || key === 'location') {\n            continue;\n          }\n          plainObj[key] = await evaluateArrayItem(value, env, collectDescriptor);\n        }\n        return plainObj;\n      }\n      \n      // Try to interpolate as a node array\n      return await interpolateAndCollect([item], env, collectDescriptor);\n  }\n}\n\n/**\n * Basic section extraction fallback\n */\nfunction extractSection(content: string, sectionName: string): string {\n  const lines = content.split('\\n');\n  const sectionRegex = new RegExp(`^#+\\\\s+${sectionName}\\\\s*$`, 'i');\n  \n  let inSection = false;\n  let sectionLevel = 0;\n  const sectionLines: string[] = [];\n  \n  for (const line of lines) {\n    if (!inSection && sectionRegex.test(line)) {\n      inSection = true;\n      sectionLevel = line.match(/^#+/)?.[0].length || 0;\n      sectionLines.push(line); // Include the header\n      continue;\n    }\n    \n    if (inSection) {\n      const headerMatch = line.match(/^(#+)\\\\s+/);\n      if (headerMatch && headerMatch[1].length <= sectionLevel) {\n        break;\n      }\n      sectionLines.push(line);\n    }\n  }\n  \n  return sectionLines.join('\\n').trim();\n}\n","import { ShadowEnvironmentCapture } from '../../env/types/ShadowEnvironmentCapture';\nimport { Environment } from '../../env/Environment';\n\n/**\n * Resolves shadow environment for a specific language with fallback chain\n * Priority: captured (lexical) > current environment (dynamic)\n * \n * @param language The language to resolve (js, javascript, node, nodejs)\n * @param capturedEnvs Shadow environments captured at definition time\n * @param currentEnv Current execution environment\n * @returns The resolved shadow environment Map or undefined\n */\nexport function resolveShadowEnvironment(\n  language: string,\n  capturedEnvs: ShadowEnvironmentCapture | undefined,\n  currentEnv: Environment\n): Map<string, any> | undefined {\n  // Normalize language aliases for consistent lookup\n  const normalizedLang = normalizeLanguage(language);\n  \n  // 1. Check captured environment first (lexical scope)\n  if (capturedEnvs) {\n    const captured = capturedEnvs[normalizedLang as keyof ShadowEnvironmentCapture];\n    if (captured && captured.size > 0) {\n      return captured;\n    }\n  }\n  \n  // 2. Fall back to dynamic scope (current environment)\n  return currentEnv.getShadowEnv(language);\n}\n\n/**\n * Detects conflicts between captured and current shadow environments\n * WHY: When modules import other modules with shadow environments, \n * we may have diamond dependencies where the same shadow function\n * exists in multiple contexts.\n */\nfunction detectShadowConflicts(\n  captured: Map<string, any> | undefined,\n  current: Map<string, any> | undefined\n): string[] {\n  const conflicts: string[] = [];\n  \n  if (captured && current) {\n    for (const [name, capturedFunc] of captured) {\n      const currentFunc = current.get(name);\n      if (currentFunc && currentFunc !== capturedFunc) {\n        conflicts.push(name);\n      }\n    }\n  }\n  \n  return conflicts;\n}\n\n/**\n * Merges shadow functions for execution context\n * Current environment functions take precedence over captured\n * Also filters out any functions that conflict with parameter names\n * \n * @param captured Shadow functions from definition time\n * @param current Shadow functions from execution environment  \n * @param paramNames Set of parameter names to avoid conflicts\n * @returns Arrays of function names and values for Function constructor\n */\nexport function mergeShadowFunctions(\n  captured: Map<string, any> | undefined,\n  current: Map<string, any> | undefined,\n  paramNames: Set<string>\n): { names: string[], values: any[] } {\n  const merged = new Map<string, any>();\n  \n  // Detect conflicts for debugging (only in debug mode)\n  if (process.env.MLLD_DEBUG === 'true') {\n    const conflicts = detectShadowConflicts(captured, current);\n    if (conflicts.length > 0) {\n      console.warn(\n        `[Shadow Environment] Conflict detected for functions: ${conflicts.join(', ')}. ` +\n        `Current environment shadows are overriding captured ones.`\n      );\n    }\n  }\n  \n  // Start with captured (lexical scope)\n  if (captured) {\n    for (const [name, func] of captured) {\n      if (!paramNames.has(name)) {\n        merged.set(name, func);\n      }\n    }\n  }\n  \n  // Override with current (dynamic scope) \n  if (current) {\n    for (const [name, func] of current) {\n      if (!paramNames.has(name)) {\n        merged.set(name, func);\n      }\n    }\n  }\n  \n  // Convert to arrays for Function constructor\n  const names: string[] = [];\n  const values: any[] = [];\n  for (const [name, func] of merged) {\n    names.push(name);\n    values.push(func);\n  }\n  \n  return { names, values };\n}\n\n/**\n * Normalizes language names to canonical form\n * js/javascript -> js, node/nodejs -> node\n */\nfunction normalizeLanguage(language: string): string {\n  switch (language) {\n    case 'js':\n    case 'javascript':\n      return 'js';\n    case 'node':\n    case 'nodejs':\n      return 'node';\n    default:\n      return language;\n  }\n}","import type { BaseMlldNode, DirectiveNode, ExeBlockNode, TextNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport type { ExecutableDefinition, CommandExecutable, CommandRefExecutable, CodeExecutable, TemplateExecutable, SectionExecutable, ResolverExecutable, PipelineExecutable, ProseExecutable } from '@core/types/executable';\nimport { interpolate, evaluate } from '../core/interpreter';\nimport { astLocationToSourceLocation } from '@core/types';\nimport {\n  createExecutableVariable,\n  createSimpleTextVariable,\n  VariableMetadataUtils,\n  type VariableSource\n} from '@core/types/variable';\n// import { ExecParameterConflictError } from '@core/errors/ExecParameterConflictError'; // Removed - parameter shadowing is allowed\nimport { resolveShadowEnvironment, mergeShadowFunctions } from './helpers/shadowEnvResolver';\nimport { isFileLoadedValue } from '@interpreter/utils/load-content-structured';\nimport { logger } from '@core/utils/logger';\nimport { AutoUnwrapManager } from './auto-unwrap-manager';\nimport { isAugmentedAssignment, isLetAssignment } from '@core/types/when';\nimport { evaluateAugmentedAssignment, evaluateLetAssignment } from './when';\nimport { VariableImporter } from './import/VariableImporter';\nimport * as path from 'path';\nimport {\n  createCapabilityContext,\n  makeSecurityDescriptor,\n  type DataLabel,\n  type CapabilityContext,\n  type SecurityDescriptor\n} from '@core/types/security';\nimport { asData, asText, isStructuredValue } from '../utils/structured-value';\nimport { InterpolationContext } from '../core/interpolation-context';\n\n/**\n * Evaluate an exe block sequentially with local scope for let/+= assignments.\n */\nexport async function evaluateExeBlock(\n  block: ExeBlockNode,\n  env: Environment,\n  args: Record<string, unknown> = {}\n): Promise<EvalResult> {\n  let blockEnv = env.createChild();\n\n  if (args && Object.keys(args).length > 0) {\n    const importer = new VariableImporter();\n    for (const [param, value] of Object.entries(args)) {\n      const variable = importer.createVariableFromValue(\n        param,\n        value,\n        'exe-param',\n        undefined,\n        { env: blockEnv }\n      );\n      blockEnv.setVariable(param, variable);\n    }\n  }\n\n  for (const stmt of block.values?.statements ?? []) {\n    if (isLetAssignment(stmt)) {\n      blockEnv = await evaluateLetAssignment(stmt, blockEnv);\n    } else if (isAugmentedAssignment(stmt)) {\n      blockEnv = await evaluateAugmentedAssignment(stmt, blockEnv);\n    } else {\n      const result = await evaluate(stmt, blockEnv);\n      blockEnv = result.env || blockEnv;\n    }\n  }\n\n  let returnValue: unknown = undefined;\n  const returnNode = block.values?.return;\n  const hasReturnValue = returnNode?.meta?.hasValue !== false;\n  if (returnNode && hasReturnValue) {\n    const returnNodes = Array.isArray(returnNode.values) ? returnNode.values : [];\n    if (returnNodes.length > 0) {\n      const returnResult = await evaluate(returnNodes, blockEnv, { isExpression: true });\n      returnValue = returnResult.value;\n      blockEnv = returnResult.env || blockEnv;\n    }\n  }\n\n  env.mergeChild(blockEnv);\n  return { value: returnValue, env };\n}\n\nasync function interpolateAndRecord(\n  nodes: any,\n  env: Environment,\n  context: InterpolationContext = InterpolationContext.Default\n): Promise<string> {\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1 ? descriptors[0] : env.mergeSecurityDescriptors(...descriptors);\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n\nfunction buildTemplateAstFromContent(content: string): any[] {\n  const ast: any[] = [];\n  const regex = /@([A-Za-z_][\\w\\.]*)/g;\n  let lastIndex = 0;\n  let match: RegExpExecArray | null;\n  while ((match = regex.exec(content)) !== null) {\n    if (match.index > lastIndex) {\n      ast.push({ type: 'Text', content: content.slice(lastIndex, match.index) });\n    }\n    ast.push({ type: 'VariableReference', identifier: match[1] });\n    lastIndex = match.index + match[0].length;\n  }\n  if (lastIndex < content.length) {\n    ast.push({ type: 'Text', content: content.slice(lastIndex) });\n  }\n  return ast;\n}\n\n/**\n * Extract parameter names from the params array.\n * \n * TODO: Remove workaround when issue #50 is fixed.\n * The grammar currently returns VariableReference nodes for params,\n * but they should be simple strings or Parameter nodes.\n */\nfunction extractParamNames(params: any[]): string[] {\n  return params.map(p => {\n    // Once fixed, this should just be: return p; (if params are strings)\n    // or: return p.name; (if params are Parameter nodes)\n    if (typeof p === 'string') {\n      return p;\n    } else if (p.type === 'VariableReference') {\n      // Current workaround for grammar issue #50\n      return p.identifier;\n    } else if (p.type === 'Parameter') {\n      // Future-proofing for when grammar is fixed\n      return p.name;\n    }\n    return '';\n  }).filter(Boolean);\n}\n\n// Parameter conflict checking removed - parameters are allowed to shadow outer scope variables\n// This is consistent with standard function parameter behavior and mlld's immutability model\n\n/**\n * Evaluate @exec directives.\n * Defines executable commands/code but doesn't run them.\n * \n * Ported from ExecDirectiveHandler.\n */\nexport async function evaluateExe(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  // Handle environment declaration first\n  if (directive.subtype === 'environment') {\n    // Handle @exec js = { ... }\n    const identifierNodes = directive.values?.identifier;\n    if (!identifierNodes || !Array.isArray(identifierNodes) || identifierNodes.length === 0) {\n      throw new Error('Exec environment directive missing language identifier');\n    }\n    \n    const identifierNode = identifierNodes[0];\n    let language: string;\n    \n    // With improved type consistency, identifierNodes is always VariableReferenceNode[]\n    if (identifierNode.type === 'VariableReference' && 'identifier' in identifierNode) {\n      language = identifierNode.identifier;\n    } else {\n      throw new Error('Exec environment language must be a simple string');\n    }\n    \n    const envRefs = directive.values?.environment || [];\n    \n    // Collect functions to inject\n    const shadowFunctions = new Map<string, any>();\n    \n    // First, set up the shadow environment so it's available for capture\n    for (const ref of envRefs) {\n      const funcName = ref.identifier;\n      const funcVar = env.getVariable(funcName);\n      \n      if (!funcVar || funcVar.type !== 'executable') {\n        throw new Error(`${funcName} is not a defined exec function`);\n      }\n      \n      // Create wrapper function that calls the mlld exec\n      const wrapper = createExecWrapper(funcName, funcVar, env);\n      \n      // For JavaScript shadow functions, create a synchronous wrapper when possible\n      let effectiveWrapper = wrapper;\n      if (language === 'js' || language === 'javascript') {\n        // Only create sync wrapper for JavaScript code (not commands or other types)\n        if (funcVar.value.type === 'code' && \n            (funcVar.value.language === 'javascript' || funcVar.value.language === 'js')) {\n          // Get the executable definition from internal\n          const execDef = (funcVar.internal as any)?.executableDef;\n          if (execDef && execDef.type === 'code') {\n            // NEW: Pass captured shadow envs through the definition\n            (execDef as any).capturedShadowEnvs =\n              (funcVar.internal as any)?.capturedShadowEnvs;\n            effectiveWrapper = createSyncJsWrapper(funcName, execDef, env);\n          }\n        }\n      }\n      \n      // Store the wrapper (sync for JS when possible, async otherwise)\n      shadowFunctions.set(funcName, effectiveWrapper);\n    }\n    \n    // Store in environment FIRST\n    env.setShadowEnv(language, shadowFunctions);\n    \n    // NOW retroactively update all the executables in the shadow environment\n    // to capture the complete shadow environment (including each other)\n    if (env.hasShadowEnvs()) {\n      const capturedEnvs = env.captureAllShadowEnvs();\n      \n      \n      // Update each function variable's metadata to include the captured shadow envs\n      for (const ref of envRefs) {\n        const funcName = ref.identifier;\n        const funcVar = env.getVariable(funcName);\n        \n        if (funcVar && funcVar.type === 'executable') {\n          // Update internal metadata to include captured shadow environments\n          funcVar.internal = {\n            ...(funcVar.internal ?? {}),\n            capturedShadowEnvs: capturedEnvs\n          };\n          // Also update the executableDef if it exists\n          const execDef = (funcVar.internal as any)?.executableDef;\n          if (execDef) {\n            (execDef as any).capturedShadowEnvs = capturedEnvs;\n          }\n        }\n      }\n    }\n    \n    return {\n      value: null,\n      env\n    };\n  }\n  \n  // Extract identifier - this is a command name, not content to interpolate\n  const identifierNodes = directive.values?.identifier;\n  if (!identifierNodes || !Array.isArray(identifierNodes) || identifierNodes.length === 0) {\n    throw new Error('Exec directive missing identifier');\n  }\n  \n  // For exec directives, extract the command name\n  const identifierNode = identifierNodes[0];\n  let identifier: string;\n  \n  // With improved type consistency, identifierNodes is always VariableReferenceNode[]\n  if (identifierNode.type === 'VariableReference' && 'identifier' in identifierNode) {\n    identifier = identifierNode.identifier;\n  } else {\n    throw new Error('Exec directive identifier must be a simple command name');\n  }\n  \n  const securityLabels = (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined;\n  const descriptor = makeSecurityDescriptor({ labels: securityLabels });\n  const capabilityContext: CapabilityContext = createCapabilityContext({\n    kind: 'exe',\n    descriptor,\n    metadata: {\n      identifier,\n      filePath: env.getCurrentFilePath()\n    },\n    operation: {\n      kind: 'exe',\n      identifier,\n      location: directive.location\n    }\n  });\n\n  let executableDef: ExecutableDefinition;\n\n\n    if (directive.subtype === 'exeCommand') {\n      const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    const withClause = directive.values?.withClause;\n\n    if (directive.meta?.isPipelineOnly && withClause?.pipeline) {\n      executableDef = {\n        type: 'pipeline',\n        pipeline: withClause.pipeline,\n        format: withClause.format,\n        parallelCap: withClause.parallel,\n        delayMs: withClause.delayMs,\n        paramNames,\n        sourceDirective: 'exec'\n      } satisfies PipelineExecutable;\n    } else {\n      const commandRef = directive.values?.commandRef;\n      if (commandRef) {\n        /**\n         * Handle executable defined as a reference to another symbol\n         * WHY: The RHS may be a simple variable reference (identity), or a true command reference.\n         *      We preserve identity bodies as templates at compile-time to avoid runtime ambiguity.\n         */\n        let refName: string | undefined;\n        const commandRefNodes = Array.isArray(commandRef) ? commandRef : [commandRef];\n        try {\n          const refCandidate = commandRefNodes[0];\n          if (refCandidate && typeof refCandidate === 'object') {\n            if ('type' in refCandidate && (refCandidate as any).type === 'VariableReference' && 'identifier' in (refCandidate as any)) {\n              refName = (refCandidate as any).identifier as string;\n            } else if ('name' in refCandidate && typeof (refCandidate as any).name === 'string') {\n              refName = (refCandidate as any).name as string;\n            }\n          }\n        } catch {}\n\n        if (!refName) {\n          refName = await interpolateAndRecord(commandRef as any, env);\n        }\n\n        const args = directive.values?.args || [];\n        const refCandidate = commandRefNodes[0];\n        const isVariableRef =\n          refCandidate &&\n          typeof refCandidate === 'object' &&\n          'type' in refCandidate &&\n          ((refCandidate as any).type === 'VariableReference' || (refCandidate as any).type === 'VariableReferenceWithTail');\n        const refFields = isVariableRef ? (refCandidate as any).fields : undefined;\n        const refPipes = isVariableRef ? (refCandidate as any).pipes : undefined;\n        const shouldTemplateFromRef =\n          isVariableRef &&\n          (((refCandidate as any).type === 'VariableReferenceWithTail') ||\n            (Array.isArray(refFields) && refFields.length > 0) ||\n            (Array.isArray(refPipes) && refPipes.length > 0));\n        const isIdentity =\n          !shouldTemplateFromRef &&\n          isVariableRef &&\n          commandRefNodes.length === 1 &&\n          paramNames.length >= 1 &&\n          args.length === 0 &&\n          typeof refName === 'string' &&\n          refName.length > 0 &&\n          refName === paramNames[0];\n\n        if (isIdentity || shouldTemplateFromRef) {\n          executableDef = {\n            type: 'template',\n            template: isIdentity\n              ? [{ type: 'VariableReference', identifier: refName }]\n              : commandRefNodes,\n            paramNames,\n            sourceDirective: 'exec'\n          } satisfies TemplateExecutable;\n          if (withClause) {\n            (executableDef as any).withClause = withClause;\n          }\n        } else {\n          executableDef = {\n            type: 'commandRef',\n            commandRef: refName,\n            commandArgs: args,\n            withClause,\n            paramNames,\n            sourceDirective: 'exec'\n          } satisfies CommandRefExecutable;\n        }\n      } else {\n        const commandNodes = directive.values?.command;\n        if (!commandNodes) {\n          throw new Error('Exec command directive missing command');\n        }\n\n        const workingDir = (directive.values as any)?.workingDir;\n        const workingDirMeta = (directive.meta as any)?.workingDirMeta || (directive.values as any)?.workingDirMeta;\n        executableDef = {\n          type: 'command',\n          commandTemplate: commandNodes,\n          withClause,\n          paramNames,\n          sourceDirective: 'exec',\n          ...(workingDir ? { workingDir } : {}),\n          ...(workingDirMeta ? { workingDirMeta } : {})\n        } satisfies CommandExecutable;\n      }\n    }\n    \n  } else if (directive.subtype === 'exeData') {\n    const dataNodes = directive.values?.data;\n    if (!dataNodes) {\n      throw new Error('Exec data directive missing data content');\n    }\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    executableDef = {\n      type: 'data',\n      dataTemplate: dataNodes,\n      paramNames,\n      sourceDirective: 'exec'\n    };\n  } else if (directive.subtype === 'exeCode') {\n    /**\n     * Handle code executable definitions\n     * WHY: Code executables run language-specific code (JS, Python, etc) with\n     * parameter binding and shadow environment access.\n     * GOTCHA: The code template is stored as AST nodes for lazy interpolation -\n     * parameters are only substituted at execution time, not definition time.\n     * CONTEXT: Enables patterns like /exe @transform(data) = js {@data.map(x => x * 2)}\n     */\n    const codeNodes = directive.values?.code;\n    if (!codeNodes) {\n      throw new Error('Exec code directive missing code');\n    }\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    const withClause = directive.values?.withClause;\n    \n    // Parameters are allowed to shadow outer scope variables\n    \n    // Language is stored in meta, not raw\n    const language = directive.meta?.language || 'javascript';\n    \n    // Store the code template (not interpolated yet)\n    const workingDir = (directive.values as any)?.workingDir;\n    const workingDirMeta = (directive.meta as any)?.workingDirMeta || (directive.values as any)?.workingDirMeta;\n    executableDef = {\n      type: 'code',\n      codeTemplate: codeNodes,\n      language,\n      paramNames,\n      sourceDirective: 'exec',\n      ...(withClause ? { withClause } : {}),\n      ...(workingDir ? { workingDir } : {}),\n      ...(workingDirMeta ? { workingDirMeta } : {})\n    } satisfies CodeExecutable;\n    \n  } else if (directive.subtype === 'exeResolver') {\n    // Handle resolver executable: @exec name(params) = @resolver/path { @payload }\n    const resolverNodes = directive.values?.resolver;\n    if (!resolverNodes) {\n      throw new Error('Exec resolver directive missing resolver path');\n    }\n    \n    // Get the resolver path (it's a literal string, not interpolated)\n    const resolverPath = await interpolateAndRecord(resolverNodes, env);\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    \n    // Parameters are allowed to shadow outer scope variables\n    \n    // Get payload nodes if present\n    const payloadNodes = directive.values?.payload;\n    \n    // Special case: If resolver is \"run\", this is likely a grammar parsing issue\n    // where \"@exec name() = @run [command]\" was parsed as execResolver instead of execCommand\n    if (resolverPath === 'run') {\n      // Look for command content immediately following in the AST\n      // This is a workaround for a grammar issue\n      throw new Error('Grammar parsing issue: @exec with @run should be parsed as execCommand, not execResolver');\n    }\n    \n    // Create resolver executable definition\n    executableDef = {\n      type: 'resolver',\n      resolverPath,\n      payloadTemplate: payloadNodes,\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies ResolverExecutable;\n    \n  } else if (directive.subtype === 'exeTemplate') {\n    /**\n     * Handle template executable definitions\n     * WHY: Template executables provide simple text interpolation with parameter\n     * substitution, useful for generating formatted output without code execution.\n     * GOTCHA: Templates use double square brackets [[...]] syntax and support full\n     * mlld interpolation including nested directives.\n     * CONTEXT: Common for report generation, formatted messages, and string templates\n     * Example: /exe @greeting(name) = [[Hello, @name!]]\n     */\n    const templateNodes = directive.values?.template;\n    if (!templateNodes) {\n      throw new Error('Exec template directive missing template');\n    }\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    \n    // Parameters are allowed to shadow outer scope variables\n    \n    // Create template executable definition\n    executableDef = {\n      type: 'template',\n      template: templateNodes,\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies TemplateExecutable;\n    \n  } else if (directive.subtype === 'exeTemplateFile') {\n    // Handle template executable loaded from external file by extension\n    // Syntax: /exe @name(params) = template \"path/to/file.att|.mtt\"\n    const pathNodes = directive.values?.path;\n    if (!pathNodes || !Array.isArray(pathNodes) || pathNodes.length === 0) {\n      throw new Error('Exec template-file directive missing path');\n    }\n    // Evaluate path nodes to resolve any variable references\n    const evaluatedPath = await interpolate(pathNodes, env);\n    const filePath = String(evaluatedPath);\n    \n    // Determine template style by extension\n    const ext = path.extname(filePath).toLowerCase();\n    if (ext !== '.att' && ext !== '.mtt') {\n      throw new Error(`Unsupported template file extension for ${filePath}. Use .att (@var) or .mtt ({{var}}).`);\n    }\n    \n    // Read file content relative to current env and parse with template body rules\n    const fileContent = await env.readFile(filePath);\n    const { parseSync } = await import('@grammar/parser');\n    const startRule = ext === '.mtt' ? 'TemplateBodyMtt' : 'TemplateBodyAtt';\n    let templateNodes: any[];\n    try {\n      templateNodes = parseSync(fileContent, { startRule });\n    } catch (err: any) {\n      // Fallback to legacy parsing when start rules are unavailable in the bundled parser\n      try {\n        let normalized = fileContent;\n        if (ext === '.mtt') {\n          // Preserve mustache-style placeholders for YAML and content; normalize simple {{var}} to @var\n          normalized = normalized.replace(/{{\\s*([A-Za-z_][\\w\\.]*)\\s*}}/g, '@$1');\n        }\n        templateNodes = buildTemplateAstFromContent(normalized);\n      } catch (fallbackErr: any) {\n        throw new Error(`Failed to parse template file ${filePath}: ${err.message}`);\n      }\n    }\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    \n    executableDef = {\n      type: 'template',\n      template: templateNodes,\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies TemplateExecutable;\n    \n  } else if (directive.subtype === 'exeSection') {\n    // Handle section exec: @exec name(file, section) = [@file # @section]\n    const pathNodes = directive.values?.path;\n    const sectionNodes = directive.values?.section;\n    if (!pathNodes || !sectionNodes) {\n      throw new Error('Exec section directive missing path or section');\n    }\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    \n    // Parameters are allowed to shadow outer scope variables\n    \n    // Get rename nodes if present\n    const renameNodes = directive.values?.rename;\n    \n    // Create section executable definition\n    executableDef = {\n      type: 'section',\n      pathTemplate: pathNodes,\n      sectionTemplate: sectionNodes,\n      renameTemplate: renameNodes,\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies SectionExecutable;\n    \n  } else if (directive.subtype === 'exeWhen') {\n    // Handle when expression executable: @exe name(params) = when: [...]\n    const contentNodes = directive.values?.content;\n    if (!contentNodes || !Array.isArray(contentNodes) || contentNodes.length === 0) {\n      throw new Error('Exec when directive missing when expression');\n    }\n    \n    const whenExprNode = contentNodes[0];\n    if (!whenExprNode || whenExprNode.type !== 'WhenExpression') {\n      throw new Error('Exec when directive content must be a WhenExpression');\n    }\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    \n    // Parameters are allowed to shadow outer scope variables\n    \n    if (process.env.DEBUG_EXEC) {\n      logger.debug('Creating exe when expression:', { \n        identifier,\n        paramNames,\n        conditionCount: whenExprNode.conditions?.length\n      });\n    }\n    \n    // Create a special executable that evaluates the when expression\n    // We'll treat this as a code executable with special handling\n    executableDef = {\n      type: 'code',\n      codeTemplate: contentNodes, // Store the WhenExpression node\n      language: 'mlld-when', // Special language marker\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies CodeExecutable;\n    \n  } else if (directive.subtype === 'exeForeach') {\n    // Handle foreach expression executable: @exe name(params) = foreach @cmd(@arrays)\n    const contentNodes = directive.values?.content;\n    if (!contentNodes || !Array.isArray(contentNodes) || contentNodes.length === 0) {\n      throw new Error('Exec foreach directive missing foreach expression');\n    }\n    \n    const foreachNode = contentNodes[0];\n    // Basic shape check\n    if (!foreachNode || (foreachNode.type !== 'foreach-command' && (foreachNode.value?.type !== 'foreach'))) {\n      throw new Error('Exec foreach directive content must be a ForeachCommandExpression');\n    }\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    \n    if (process.env.DEBUG_EXEC) {\n      logger.debug('Creating exe foreach expression:', { \n        identifier,\n        paramNames\n      });\n    }\n    \n    // Create a special executable that evaluates the foreach expression\n    executableDef = {\n      type: 'code',\n      codeTemplate: contentNodes, // Store the Foreach AST node\n      language: 'mlld-foreach', // Special language marker\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies CodeExecutable;\n  \n  } else if (directive.subtype === 'exeFor') {\n    // Handle for expression executable: @exe name(params) = for @var in @collection => expression\n    const contentNodes = directive.values?.content;\n    if (!contentNodes || !Array.isArray(contentNodes) || contentNodes.length === 0) {\n      throw new Error('Exec for directive missing for expression');\n    }\n    \n    const forExprNode = contentNodes[0];\n    if (!forExprNode || forExprNode.type !== 'ForExpression') {\n      throw new Error('Exec for directive content must be a ForExpression');\n    }\n    \n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n    \n    // Parameters are allowed to shadow outer scope variables\n    \n    if (process.env.DEBUG_EXEC) {\n      logger.debug('Creating exe for expression:', { \n        identifier,\n        paramNames,\n        variable: forExprNode.variable?.identifier\n      });\n    }\n    \n    // Create a special executable that evaluates the for expression\n    // We'll treat this as a code executable with special handling\n    executableDef = {\n      type: 'code',\n      codeTemplate: contentNodes, // Store the ForExpression node\n      language: 'mlld-for', // Special language marker\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies CodeExecutable;\n\n  } else if (directive.subtype === 'exeBlock') {\n    const statements = (directive.values as any)?.statements || [];\n    const returnStmt = (directive.values as any)?.return;\n    \n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n\n    const blockNode: ExeBlockNode = {\n      type: 'ExeBlock',\n      nodeId: directive.nodeId,\n      values: {\n        statements,\n        ...(returnStmt ? { return: returnStmt } : {})\n      },\n      meta: {\n        statementCount: (directive.meta as any)?.statementCount ?? statements.length,\n        hasReturn: (directive.meta as any)?.hasReturn ?? Boolean(returnStmt)\n      },\n      location: directive.location\n    };\n\n    executableDef = {\n      type: 'code',\n      codeTemplate: [blockNode],\n      language: 'mlld-exe-block',\n      paramNames,\n      sourceDirective: 'exec'\n    } satisfies CodeExecutable;\n\n  } else if (directive.subtype === 'exeProse' || directive.subtype === 'exeProseFile' || directive.subtype === 'exeProseTemplate') {\n    // Handle prose executable: prose:@config { ... } or prose:@config \"file.prose\"\n    const configRefNodes = directive.values?.configRef;\n    if (!configRefNodes || !Array.isArray(configRefNodes) || configRefNodes.length === 0) {\n      throw new Error('Prose executable missing config reference');\n    }\n\n    // Get parameter names if any\n    const params = directive.values?.params || [];\n    const paramNames = extractParamNames(params);\n\n    const contentType = directive.values?.contentType as 'inline' | 'file' | 'template';\n\n    if (contentType === 'inline') {\n      // Inline prose: prose:@config { session \"...\" }\n      const contentNodes = directive.values?.content;\n      if (!contentNodes) {\n        throw new Error('Inline prose executable missing content');\n      }\n      executableDef = {\n        type: 'prose',\n        configRef: configRefNodes,\n        contentType: 'inline',\n        contentTemplate: contentNodes,\n        paramNames,\n        sourceDirective: 'exec'\n      } satisfies ProseExecutable;\n    } else {\n      // File-based prose: prose:@config \"file.prose\" or prose:@config template \"file.prose.att\"\n      const pathNodes = directive.values?.path;\n      if (!pathNodes || !Array.isArray(pathNodes) || pathNodes.length === 0) {\n        throw new Error('File-based prose executable missing path');\n      }\n      executableDef = {\n        type: 'prose',\n        configRef: configRefNodes,\n        contentType,\n        pathTemplate: pathNodes,\n        paramNames,\n        sourceDirective: 'exec'\n      } satisfies ProseExecutable;\n    }\n\n    if (process.env.DEBUG_EXEC) {\n      logger.debug('Creating exe prose:', {\n        identifier,\n        paramNames,\n        contentType,\n        hasConfig: true\n      });\n    }\n\n  } else {\n    throw new Error(`Unsupported exec subtype: ${directive.subtype}`);\n  }\n  \n  // Create variable source metadata\n  const source: VariableSource = {\n    directive: 'var', // exe directives create variables in the new system\n    syntax: 'code', // Default to code syntax\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n  \n  // Adjust syntax based on executable type\n  if (executableDef.type === 'command' || executableDef.type === 'commandRef' || executableDef.type === 'pipeline') {\n    source.syntax = 'command';\n  } else if (executableDef.type === 'template') {\n    source.syntax = 'template';\n  } else if (executableDef.type === 'data') {\n    source.syntax = 'object';\n  } else if (executableDef.type === 'prose') {\n    source.syntax = 'prose';\n  }\n  \n  // Extract language for code executables\n  const language = executableDef.type === 'code' \n    ? (executableDef.language as 'js' | 'node' | 'python' | 'sh' | undefined)\n    : undefined;\n  \n  /**\n   * Create the executable variable\n   * WHY: Executable variables wrap command/code/template definitions with parameter\n   * metadata, enabling them to be invoked like functions with argument binding.\n   * GOTCHA: The variable.value.template is set AFTER creation because the executable\n   * definition structure varies by type (commandTemplate vs codeTemplate vs template).\n   * CONTEXT: These variables are used by /run directives, pipelines, and anywhere\n   * a parameterized executable can be invoked.\n   */\n  const location = astLocationToSourceLocation(directive.location, env.getCurrentFilePath());\n  \n    // CONTEXT: Shadow environments may be present; capture them for later execution\n  \n  const metadata: Record<string, any> = {\n    definedAt: location,\n    executableDef\n  };\n\n  if (env.hasShadowEnvs()) {\n    metadata.capturedShadowEnvs = env.captureAllShadowEnvs();\n  }\n\n    // Only capture module environment when we're evaluating a module for import\n    if (env.getIsImporting()) {\n      metadata.capturedModuleEnv = env.captureModuleEnvironment();\n    }\n\n    const executableTypeForVariable =\n      executableDef.type === 'code'\n        ? 'code'\n        : executableDef.type === 'data'\n          ? 'data'\n          : 'command';\n\n  let executableDescriptor = descriptor;\n  if (executableDef.type === 'command') {\n    const commandTaintDescriptor = makeSecurityDescriptor({ taint: ['src:exec'] });\n    executableDescriptor = executableDescriptor\n      ? env.mergeSecurityDescriptors(executableDescriptor, commandTaintDescriptor)\n      : commandTaintDescriptor;\n  }\n\n  const metadataWithSecurity = VariableMetadataUtils.applySecurityMetadata(metadata, {\n      existingDescriptor: executableDescriptor,\n      capability: capabilityContext\n    });\n\n    const variable = createExecutableVariable(\n      identifier,\n      executableTypeForVariable,\n      '', // Template will be filled from executableDef\n      executableDef.paramNames || [],\n      language,\n      source,\n      {\n        metadata: metadataWithSecurity,\n        internal: {\n          executableDef\n        }\n      }\n    );\n\n    // Set the actual template/command content\n    if (executableDef.type === 'command') {\n      variable.value.template = executableDef.commandTemplate;\n    } else if (executableDef.type === 'code') {\n      variable.value.template = executableDef.codeTemplate;\n    } else if (executableDef.type === 'template') {\n      variable.value.template = executableDef.template;\n    } else if (executableDef.type === 'data') {\n      (variable.value as any).template = executableDef.dataTemplate;\n    }\n    \n    env.setVariable(identifier, variable);\n    \n    // Return the executable definition (no output for variable definitions)\n    return { value: executableDef, env };\n}\n\n/**\n * Create a synchronous wrapper for JavaScript shadow functions\n * This allows simple JS expressions to be called without await\n */\nfunction createSyncJsWrapper(\n  funcName: string,\n  definition: CodeExecutable,\n  env: Environment\n): Function {\n  return function(...args: any[]) {\n    // Get parameter names from the definition\n    const params = definition.paramNames || [];\n    \n    // Create a child environment for parameter substitution\n    const execEnv = env.createChild();\n    \n    // Build params object for code execution\n    const codeParams: Record<string, any> = {};\n    for (let i = 0; i < params.length; i++) {\n      const paramName = params[i];\n      let argValue = args[i];\n      \n      // Always add the parameter, even if undefined\n      // This ensures JS code can reference all declared parameters\n      if (argValue !== undefined) {\n        // Auto-unwrap without async shelf (sync context)\n        if (isStructuredValue(argValue)) {\n          argValue = asData(argValue);\n        } else if (isFileLoadedValue(argValue)) {\n          // Handle LoadContentResult format\n          argValue = argValue.content;\n        }\n\n        // Try to parse numeric values (same logic as async wrapper)\n        if (typeof argValue === 'string') {\n          const numValue = Number(argValue);\n          if (!isNaN(numValue) && argValue.trim() !== '') {\n            // If it's a valid number, use the numeric value\n            argValue = numValue;\n          }\n        }\n      }\n      \n      // Set the parameter value (will be undefined if not provided)\n      codeParams[paramName] = argValue;\n    }\n    \n    // Get the code template\n    const codeTemplate = definition.codeTemplate;\n    if (!codeTemplate) {\n      throw new Error(`Function ${funcName} has no code template`);\n    }\n    \n    // For synchronous execution, we need to evaluate the code directly\n    // Since this is for 'js' (not 'node'), we can use the in-process execution\n    let code: string;\n    try {\n      // Simple interpolation for Text nodes\n      code = codeTemplate.map(node => {\n        if (node.type === 'Text') {\n          return node.content;\n        }\n        // For now, only support simple text templates\n        throw new Error(`Synchronous shadow functions only support simple code templates`);\n      }).join('');\n    } catch (error) {\n      throw new Error(`Cannot create synchronous wrapper for ${funcName}: ${error.message}`);\n    }\n    \n    // OLD CODE TO REPLACE:\n    // const shadowEnv = env.getShadowEnv('js') || env.getShadowEnv('javascript');\n    \n    // NEW CODE:\n    // Resolve shadow environment with capture support\n    const capturedEnvs = (definition as any).capturedShadowEnvs;\n    const shadowEnv = resolveShadowEnvironment('js', capturedEnvs, env);\n    \n    // OLD CODE TO REPLACE:\n    // const shadowFunctions: Record<string, any> = {};\n    // const shadowNames: string[] = [];\n    // const shadowValues: any[] = [];\n    // \n    // if (shadowEnv) {\n    //   for (const [name, func] of shadowEnv) {\n    //     if (!codeParams[name]) { // Don't override parameters\n    //       shadowFunctions[name] = func;\n    //       shadowNames.push(name);\n    //       shadowValues.push(func);\n    //     }\n    //   }\n    // }\n    \n    // NEW CODE:\n    // Merge shadow functions (avoiding parameter conflicts)\n    const paramSet = new Set(Object.keys(codeParams));\n    const { names: shadowNames, values: shadowValues } = \n      mergeShadowFunctions(shadowEnv, undefined, paramSet);\n    \n    // Rest of the function remains the same...\n    const allParamNames = [...Object.keys(codeParams), ...shadowNames];\n    const allParamValues = [...Object.values(codeParams), ...shadowValues];\n    \n    // Build function body\n    let functionBody = code;\n    const trimmedCode = code.trim();\n    \n    // Check if this is an expression that should be returned\n    const isExpression = (\n      (!code.includes('return') && !code.includes(';')) ||\n      (trimmedCode.startsWith('(') && trimmedCode.endsWith(')'))\n    );\n    \n    if (isExpression) {\n      functionBody = `return (${functionBody})`;\n    }\n    \n    // Create and execute the function with shadow functions in scope\n    const fn = new Function(...allParamNames, functionBody);\n    return fn(...allParamValues);\n  };\n}\n\n/**\n * Create a wrapper function that bridges JS function calls to mlld exec invocations\n */\nfunction createExecWrapper(\n  execName: string, \n  execVar: ExecutableVariable,\n  env: Environment\n): Function {\n  return async function(...args: any[]) {\n    // Get the executable definition from internal\n    const definition = (execVar.internal as any)?.executableDef;\n    if (!definition) {\n      throw new Error(`Executable ${execName} has no definition in metadata`);\n    }\n    \n    // Get parameter names from the definition\n    const params = definition.paramNames || [];\n    \n    // Create a child environment for parameter substitution\n    const execEnv = env.createChild();\n    \n    // Bind arguments to parameters\n    for (let i = 0; i < params.length; i++) {\n      const paramName = params[i];\n      const argValue = args[i];\n      if (argValue !== undefined) {\n        // For template interpolation, we need string representation\n        const stringValue =\n          typeof argValue === 'string'\n            ? argValue\n            : argValue === null || argValue === undefined\n              ? String(argValue)\n              : typeof argValue === 'object'\n                ? (isStructuredValue(argValue) ? asText(argValue) : JSON.stringify(argValue))\n                : String(argValue);\n        \n        const paramVar = createSimpleTextVariable(\n          paramName,\n          stringValue,\n          {\n            directive: 'var',\n            syntax: 'quoted',\n            hasInterpolation: false,\n            isMultiLine: false\n          },\n          {\n            internal: {\n              isSystem: true,\n              isParameter: true\n            }\n          }\n        );\n        execEnv.setParameterVariable(paramName, paramVar);\n      }\n    }\n    \n    let result: string;\n    \n    if (definition.type === 'command') {\n      // Execute command with interpolated template\n      const commandTemplate = definition.commandTemplate;\n      if (!commandTemplate) {\n        throw new Error(`Command ${execName} has no command template`);\n      }\n      \n      // Interpolate the command template with parameters\n      const command = await interpolateAndRecord(\n        commandTemplate,\n        execEnv,\n        InterpolationContext.ShellCommand\n      );\n      \n      // Build environment variables from parameters for shell execution\n      const envVars: Record<string, string> = {};\n      for (let i = 0; i < params.length; i++) {\n        const paramName = params[i];\n        const argValue = args[i];\n        if (argValue !== undefined) {\n          envVars[paramName] = String(argValue);\n        }\n      }\n      \n      // Execute the command with environment variables\n      result = await execEnv.executeCommand(command, { env: envVars });\n    } else if (definition.type === 'code') {\n      // Execute code with interpolated template\n      const codeTemplate = definition.codeTemplate;\n      if (!codeTemplate) {\n        throw new Error(`Code command ${execName} has no code template`);\n      }\n      \n      // Interpolate the code template with parameters\n      const code = await interpolateAndRecord(codeTemplate, execEnv);\n      \n      // Build params object for code execution\n      const codeParams: Record<string, any> = {};\n      for (let i = 0; i < params.length; i++) {\n        const paramName = params[i];\n        let argValue = args[i];\n        \n        // Always add the parameter, even if undefined\n        // This ensures Node.js code can reference all declared parameters\n        if (argValue !== undefined) {\n          // Ensure we await any promises in arguments\n          argValue = argValue instanceof Promise ? await argValue : argValue;\n          \n          // Auto-unwrap LoadContentResult objects\n          argValue = AutoUnwrapManager.unwrap(argValue);\n          \n          // Try to parse numeric values\n          if (typeof argValue === 'string') {\n            const numValue = Number(argValue);\n            if (!isNaN(numValue) && argValue.trim() !== '') {\n              // If it's a valid number, use the numeric value\n              argValue = numValue;\n            }\n          }\n        }\n        \n        // Set the parameter value (will be undefined if not provided)\n        codeParams[paramName] = argValue;\n      }\n      \n      // NEW CODE: Pass captured shadow environments to executors\n      // Get captured shadow environments from executable internal\n      const capturedEnvs = (execVar.internal as any)?.capturedShadowEnvs;\n      \n      \n      // For JS/Node execution, pass captured envs through params\n      // Using __ prefix following mlld's internal property pattern\n      if (capturedEnvs && (definition.language === 'js' || definition.language === 'javascript' || \n                           definition.language === 'node' || definition.language === 'nodejs')) {\n        (codeParams as any).__capturedShadowEnvs = capturedEnvs;\n      }\n      \n      // Debug logging\n      // Note: Don't use console.log in exec functions as it's captured\n      // if (process.env.MLLD_DEBUG) {\n      //   console.log(`Executing ${execName} with:`, { code, params: codeParams });\n      // }\n      \n      // Execute the code with parameters\n      result = await execEnv.executeCode(\n        code,\n        definition.language || 'javascript',\n        codeParams\n      );\n    } else if (definition.type === 'template') {\n      // Execute template with interpolated content\n      const templateNodes = definition.template;\n      if (!templateNodes) {\n        throw new Error(`Template ${execName} has no template content`);\n      }\n      \n      // Interpolate the template with parameters\n      result = await interpolateAndRecord(templateNodes, execEnv);\n    } else if (definition.type === 'data') {\n      const { evaluateDataValue } = await import('./data-value-evaluator');\n      const dataValue = await evaluateDataValue(definition.dataTemplate as any, execEnv);\n      try {\n        return JSON.parse(JSON.stringify(dataValue));\n      } catch {\n        return dataValue;\n      }\n    } else if (definition.type === 'section') {\n      // Extract section from file\n      throw new Error(`Section executables cannot be invoked from shadow environments yet`);\n    } else if (definition.type === 'resolver') {\n      // Invoke resolver\n      throw new Error(`Resolver executables cannot be invoked from shadow environments yet`);\n    } else if (definition.type === 'commandRef') {\n      // Handle command references\n      throw new Error(`Command reference executables cannot be invoked from shadow environments yet`);\n    } else {\n      throw new Error(`Unknown command type: ${definition.type}`);\n    }\n    \n    // Try to parse result as JSON for better JS integration\n    try {\n      return JSON.parse(result);\n    } catch {\n      return result; // Return as string if not JSON\n    }\n  };\n}\n","/**\n * When Expression Evaluator\n * \n * Handles value-returning when expressions used in /var and /exe contexts.\n * Distinct from directive /when which executes side effects.\n */\n\nimport type { WhenExpressionNode, WhenConditionPair, WhenEntry } from '@core/types/when';\nimport { isLetAssignment, isAugmentedAssignment, isConditionPair } from '@core/types/when';\nimport type { BaseMlldNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult, EvaluationContext } from '../core/interpreter';\nimport { MlldWhenExpressionError } from '@core/errors';\nimport { evaluate } from '../core/interpreter';\nimport { InterpolationContext } from '../core/interpolation-context';\nimport { evaluateCondition, conditionTargetsDenied } from './when';\nimport { logger } from '@core/utils/logger';\nimport { asText, isStructuredValue, ensureStructuredValue } from '../utils/structured-value';\nimport { VariableImporter } from './import/VariableImporter';\nimport { combineValues } from '../utils/value-combine';\nimport { extractVariableValue } from '../utils/variable-resolution';\nimport { isContinueLiteral, isDoneLiteral, type ContinueLiteralNode, type DoneLiteralNode } from '@core/types/control';\nimport { evaluateUnifiedExpression } from './expressions';\n\nexport interface WhenExpressionOptions {\n  denyMode?: boolean;\n}\n\ntype InterpolateFn = typeof import('../core/interpreter').interpolate;\nlet cachedInterpolateFn: InterpolateFn | null = null;\n\nasync function getInterpolateFn(): Promise<InterpolateFn> {\n  if (!cachedInterpolateFn) {\n    const module = await import('../core/interpreter');\n    cachedInterpolateFn = module.interpolate;\n  }\n  return cachedInterpolateFn;\n}\n\n/**\n * Check if a condition is the 'none' literal\n */\nfunction isNoneCondition(condition: any): boolean {\n  return condition?.type === 'Literal' && condition?.valueType === 'none';\n}\n\nasync function normalizeActionValue(value: unknown, actionEnv: Environment): Promise<unknown> {\n  let normalized = value;\n\n  if (\n    normalized &&\n    typeof normalized === 'object' &&\n    'wrapperType' in (normalized as Record<string, unknown>) &&\n    Array.isArray((normalized as { content?: unknown[] }).content)\n  ) {\n    try {\n      const interpolateFn = await getInterpolateFn();\n      normalized = await interpolateFn((normalized as { content: any[] }).content, actionEnv);\n    } catch {\n      normalized = String(normalized as any);\n    }\n  }\n\n  if (isStructuredValue(normalized)) {\n    return normalized;\n  }\n\n  if (normalized && typeof normalized === 'object' && 'type' in (normalized as Record<string, unknown>)) {\n    const nodeType = (normalized as Record<string, unknown>).type;\n\n    // Handle Literal nodes directly - extract the value\n    if (nodeType === 'Literal' && 'value' in (normalized as Record<string, unknown>)) {\n      const valueType = (normalized as Record<string, unknown>).valueType;\n      if (valueType === 'done' || valueType === 'continue') {\n        return normalized;\n      }\n      normalized = (normalized as { value: unknown }).value;\n    } else {\n      // Try to extract variable value for other node types\n      const { extractVariableValue } = await import('../utils/variable-resolution');\n      try {\n        normalized = await extractVariableValue(normalized as any, actionEnv);\n      } catch (error) {\n        logger.debug('Could not extract variable value in when expression:', error);\n      }\n    }\n  }\n\n  return normalized;\n}\n\nasync function evaluateControlLiteral(\n  literal: DoneLiteralNode | ContinueLiteralNode,\n  env: Environment\n): Promise<unknown> {\n  const val = literal.value;\n  if (Array.isArray(val)) {\n    const target = val.length === 1 ? val[0] : val;\n    if (target && typeof target === 'object' && 'type' in (target as Record<string, unknown>)) {\n      const evaluated = await evaluateUnifiedExpression(target as any, env);\n      return evaluated.value;\n    }\n    const evaluated = await evaluate(val as any, env, { isExpression: true });\n    return evaluated.value;\n  }\n  if (val === 'done' || val === 'continue') {\n    return undefined;\n  }\n  return val;\n}\n\n/**\n * Validate that 'none' conditions are placed correctly in a when block\n * Only checks condition pairs, not let assignments\n */\nfunction validateNonePlacement(entries: WhenEntry[]): void {\n  // Filter to only condition pairs for validation\n  const conditionPairs = entries.filter(isConditionPair);\n\n  let foundNone = false;\n  let foundWildcard = false;\n\n  for (let i = 0; i < conditionPairs.length; i++) {\n    const condition = conditionPairs[i].condition;\n\n    if (condition.length === 1 && isNoneCondition(condition[0])) {\n      foundNone = true;\n    } else if (condition.length === 1 && condition[0]?.type === 'Literal' && condition[0]?.valueType === 'wildcard') {\n      foundWildcard = true;\n      if (foundNone) {\n        // * after none is technically valid but makes none unreachable\n        continue;\n      }\n    } else if (foundNone) {\n      throw new MlldWhenExpressionError(\n        'The \"none\" keyword can only appear as the last condition(s) in a when block',\n        condition[0]?.location\n      );\n    }\n\n    if (foundWildcard && condition.length === 1 && isNoneCondition(condition[0])) {\n      throw new MlldWhenExpressionError(\n        'The \"none\" keyword cannot appear after \"*\" (wildcard) as it would never be reached',\n        condition[0].location\n      );\n    }\n  }\n}\n\n/**\n * Evaluates a when expression node to return a value.\n * \n * Key differences from directive /when:\n * 1. Returns the value of the matching action (not empty string)\n * 2. Returns null if no conditions match\n * 3. Supports tail modifiers on the result\n * 4. Uses first-match semantics\n */\nexport async function evaluateWhenExpression(\n  node: WhenExpressionNode,\n  env: Environment,\n  context?: EvaluationContext,\n  options?: WhenExpressionOptions\n): Promise<EvalResult> {\n  // console.error('🚨 WHEN-EXPRESSION EVALUATOR CALLED');\n  \n  // Validate none placement\n  validateNonePlacement(node.conditions);\n  \n  const errors: Error[] = [];\n  const denyMode = Boolean(options?.denyMode);\n  let deniedHandlerRan = false;\n  \n  // Check if we have a \"first\" modifier (stop after first match)\n  const isFirstMode = node.meta?.modifier === 'first';\n\n  const boundIdentifier = (node as any).boundIdentifier || node.meta?.boundIdentifier;\n  const hasBoundValue = Boolean((node as any).boundValue && typeof boundIdentifier === 'string' && boundIdentifier.length > 0);\n  let boundValue: unknown;\n\n  if (hasBoundValue) {\n    const boundResult = await evaluate((node as any).boundValue, env, context);\n    boundValue = boundResult.value;\n  }\n\n  const setBoundValue = (targetEnv: Environment) => {\n    if (!hasBoundValue) return;\n    const importer = new VariableImporter();\n    const variable = importer.createVariableFromValue(\n      boundIdentifier,\n      boundValue,\n      'let',\n      undefined,\n      { env: targetEnv }\n    );\n    targetEnv.setVariable(boundIdentifier, variable);\n  };\n  \n  // Track results from all matching conditions (for bare when)\n  let lastMatchValue: any = null;\n  let hasMatch = false;\n  let hasNonNoneMatch = false;\n  let hasValueProducingMatch = false;  // Track if any condition produced an actual return value (not just side effects)\n  let lastNoneValue: any = null;\n  let accumulatedEnv = env;\n  const buildResult = (value: unknown, environment: Environment): EvalResult => ({\n    value,\n    env: environment,\n    internal: deniedHandlerRan ? { deniedHandlerRan: true } : undefined\n  });\n  \n  // Empty conditions array - return null\n  if (node.conditions.length === 0) {\n    return buildResult(null, env);\n  }\n  \n  // Check if any condition pair has an action (filter out let assignments)\n  const conditionPairs = node.conditions.filter(isConditionPair);\n  const hasAnyAction = conditionPairs.some(c => c.action && c.action.length > 0);\n  if (!hasAnyAction) {\n    logger.warn('WhenExpression has no actions defined');\n    return buildResult(null, env);\n  }\n\n  // Check all actions for code blocks upfront (only condition pairs, not let assignments)\n  for (let i = 0; i < conditionPairs.length; i++) {\n    const pair = conditionPairs[i];\n    if (pair.action && pair.action.length > 0) {\n      const hasCodeExecution = pair.action.some(actionNode => {\n        if (typeof actionNode === 'object' && actionNode !== null && 'type' in actionNode) {\n          return actionNode.type === 'code' || actionNode.type === 'command' ||\n                 (actionNode.type === 'nestedDirective' && actionNode.directive === 'run');\n        }\n        return false;\n      });\n\n      if (hasCodeExecution) {\n        throw new MlldWhenExpressionError(\n          'Code blocks are not supported in when expressions. Define your logic in a separate /exe function and call it instead.',\n          node.location,\n          { conditionIndex: i, phase: 'action', type: 'code-block-not-supported' }\n        );\n      }\n    }\n  }\n  \n  // First pass: Evaluate entries in order (let assignments and non-none conditions)\n  for (let i = 0; i < node.conditions.length; i++) {\n    const entry = node.conditions[i];\n\n    // Handle let assignments - evaluate and store in accumulated environment\n    if (isLetAssignment(entry)) {\n      let value: unknown;\n      // Check if value is a raw primitive (number, boolean, null, string) or contains nodes\n      const firstValue = Array.isArray(entry.value) && entry.value.length > 0 ? entry.value[0] : entry.value;\n      const isRawPrimitive = firstValue === null ||\n        typeof firstValue === 'number' ||\n        typeof firstValue === 'boolean' ||\n        (typeof firstValue === 'string' && !('type' in (firstValue as any)));\n\n      if (isRawPrimitive) {\n        // For raw primitives, use the value directly\n        value = entry.value.length === 1 ? firstValue : entry.value;\n      } else {\n        // For nodes, evaluate them\n        const valueResult = await evaluate(entry.value, accumulatedEnv, {\n          ...(context || {}),\n          isExpression: true\n        });\n        value = valueResult.value;\n      }\n\n      const importer = new VariableImporter();\n      const variable = importer.createVariableFromValue(\n        entry.identifier,\n        value,\n        'let',\n        undefined,\n        { env: accumulatedEnv }\n      );\n      accumulatedEnv = accumulatedEnv.createChild();\n      accumulatedEnv.setVariable(entry.identifier, variable);\n      continue;\n    }\n\n    // Handle augmented assignments - modify existing local variable\n    if (isAugmentedAssignment(entry)) {\n      // Get existing variable - must exist and be a let binding\n      const existing = accumulatedEnv.getVariable(entry.identifier);\n      if (!existing) {\n        throw new MlldWhenExpressionError(\n          `Cannot use += on undefined variable @${entry.identifier}. ` +\n          `Use \"let @${entry.identifier} = ...\" first.`,\n          entry.location\n        );\n      }\n\n      // Evaluate the RHS value\n      let rhsValue: unknown;\n      const firstValue = Array.isArray(entry.value) && entry.value.length > 0 ? entry.value[0] : entry.value;\n      const isRawPrimitive = firstValue === null ||\n        typeof firstValue === 'number' ||\n        typeof firstValue === 'boolean' ||\n        (typeof firstValue === 'string' && !('type' in (firstValue as any)));\n\n      if (isRawPrimitive) {\n        rhsValue = entry.value.length === 1 ? firstValue : entry.value;\n      } else {\n        const rhsResult = await evaluate(entry.value, accumulatedEnv, {\n          ...(context || {}),\n          isExpression: true\n        });\n        rhsValue = rhsResult.value;\n      }\n\n      // Get current value of the variable\n      const existingValue = await extractVariableValue(existing, accumulatedEnv);\n\n      // Combine values using the += semantics\n      const combined = combineValues(existingValue, rhsValue, entry.identifier);\n\n      // Update variable in local scope (use updateVariable to bypass redefinition check)\n      const importer = new VariableImporter();\n      const updatedVar = importer.createVariableFromValue(\n        entry.identifier,\n        combined,\n        'let',\n        undefined,\n        { env: accumulatedEnv }\n      );\n      accumulatedEnv.updateVariable(entry.identifier, updatedVar);\n      continue;\n    }\n\n    // From here on, entry is a condition pair\n    const pair = entry as WhenConditionPair;\n\n    // Check if this is a none condition\n    if (pair.condition.length === 1 && isNoneCondition(pair.condition[0])) {\n      // Skip none conditions in first pass\n      continue;\n    }\n\n    if (denyMode && !conditionTargetsDenied(pair.condition)) {\n      continue;\n    }\n\n    try {\n      // Evaluate the condition\n      const conditionEnv = hasBoundValue ? accumulatedEnv.createChild() : accumulatedEnv;\n      if (hasBoundValue) setBoundValue(conditionEnv);\n      const conditionResult = await evaluateCondition(pair.condition, conditionEnv);\n\n      if (process.env.DEBUG_WHEN) {\n        logger.debug('WhenExpression condition result:', { \n          index: i, \n          conditionResult,\n          hasAction: !!(pair.action && pair.action.length > 0)\n        });\n      }\n      \n      if (conditionResult) {\n        // Condition matched - evaluate the action\n        hasMatch = true;\n        hasNonNoneMatch = true;\n        const matchedDeniedCondition = conditionTargetsDenied(pair.condition);\n        if (matchedDeniedCondition) {\n          deniedHandlerRan = true;\n        }\n        \n        if (!pair.action || pair.action.length === 0) {\n          // No action for this condition - continue to next\n          continue;\n        }\n        try {\n          // Special-case: detect retry with optional hint without evaluating side-effects\n          // Pattern: action starts with a RetryLiteral, optionally followed by a Text node (hint)\n          if (Array.isArray(pair.action) && pair.action.length >= 1) {\n            const first = pair.action[0] as any;\n            if (first && typeof first === 'object' && first.type === 'Literal' && first.value === 'retry') {\n              let value: any = 'retry';\n              // If there are additional nodes after retry, evaluate them as hint expression\n              if (pair.action.length > 1) {\n                const hintNodes = pair.action.slice(1);\n                const hintEnv = accumulatedEnv.createChild();\n                try {\n                  let hintValue: any;\n                  const firstNode: any = hintNodes[0];\n                  if (firstNode && typeof firstNode === 'object' && 'type' in firstNode && firstNode.type === 'object') {\n                    // Object literal hint → evaluate as data value to preserve object\n                    const { evaluateDataValue } = await import('../eval/data-value-evaluator');\n                    hintValue = await evaluateDataValue(firstNode, hintEnv);\n                  } else {\n                    // String/function/exec/template hint → interpolate to plain string\n                    // Check if the first node is a wrapper with content\n                    const interpolateFn = await getInterpolateFn();\n                    if (firstNode && typeof firstNode === 'object' && 'content' in firstNode && Array.isArray(firstNode.content)) {\n                      hintValue = await interpolateFn(firstNode.content, hintEnv);\n                    } else {\n                      hintValue = await interpolateFn(hintNodes as any, hintEnv);\n                    }\n                    if (typeof hintValue !== 'string') {\n                      // Defensive: ensure non-object hints are plain strings\n                      try {\n                        hintValue = String(hintValue);\n                      } catch {\n                        hintValue = '';\n                      }\n                    }\n                  }\n                  value = { value: 'retry', hint: hintValue };\n                } catch {\n                  // Fall back to plain retry on evaluation failure\n                  value = 'retry';\n                }\n              }\n              // In \"first\" mode, return immediately after first match\n              if (isFirstMode) {\n                return buildResult(value, accumulatedEnv);\n              }\n              lastMatchValue = value;\n              hasMatch = true;\n              hasValueProducingMatch = true;  // action produces a value\n              continue;\n            }\n          }\n\n          // Debug: What are we trying to evaluate?\n          if (Array.isArray(pair.action) && pair.action[0]) {\n            const firstAction = pair.action[0];\n            logger.debug('WhenExpression evaluating action:', {\n              actionType: firstAction.type,\n              actionKind: firstAction.kind,\n              actionSubtype: firstAction.subtype\n            });\n          }\n          \n          // Evaluate the action to get its value\n          // IMPORTANT SCOPING RULE:\n          // - /when (directive) uses global scope semantics (handled elsewhere)\n          // - when: [...] in /exe uses LOCAL scope – evaluate actions in a child env\n          //\n          // Also: Local variable assignments inside earlier actions must be\n          // visible to later actions in the same when-expression. We therefore\n          // evaluate each action in a child env and merge resulting variable\n          // bindings back into the accumulatedEnv after evaluation.\n          const actionEnv = accumulatedEnv.createChild();\n          let actionResult: EvalResult | null = null;\n          let value: unknown;\n          const wrapperCandidate =\n            pair.action.length === 1 &&\n            pair.action[0] &&\n            typeof pair.action[0] === 'object' &&\n            !('type' in (pair.action[0] as BaseMlldNode)) &&\n            Array.isArray((pair.action[0] as any).content)\n              ? (pair.action[0] as { content: any[] })\n              : null;\n\n          if (wrapperCandidate) {\n            const interpolateFn = await getInterpolateFn();\n            value = await interpolateFn(wrapperCandidate.content, actionEnv, InterpolationContext.Template);\n          } else {\n            // FIXED: Suppress side effects in when expressions used in /exe functions\n            // Side effects should be handled by the calling context (e.g., /show @func())\n            // Evaluate the action in normal directive context so effects stream.\n            // We avoid forcing isExpression here to preserve effect emission.\n            actionResult = await evaluate(pair.action, actionEnv, context);\n            value = actionResult.value;\n          }\n          value = await normalizeActionValue(value, actionEnv);\n          const executionEnv = actionResult?.env ?? actionEnv;\n          if (isDoneLiteral(value as any)) {\n            const resolved = await evaluateControlLiteral(value as any, executionEnv);\n            value = { __whileControl: 'done', value: resolved };\n          } else if (isContinueLiteral(value as any)) {\n            const resolved = await evaluateControlLiteral(value as any, executionEnv);\n            value = { __whileControl: 'continue', value: resolved };\n          }\n\t          if (Array.isArray(pair.action) && pair.action.length === 1) {\n\t            const singleAction = pair.action[0];\n\t            if (singleAction && typeof singleAction === 'object' && singleAction.type === 'Directive') {\n\t              const directiveKind = singleAction.kind;\n\t              // For side-effect directives, handle appropriately for expression context\n\t              if (directiveKind === 'show') {\n\t                const textValue =\n\t                  typeof value === 'string'\n\t                    ? value\n\t                    : isStructuredValue(value)\n\t                      ? asText(value)\n\t                      : value === null || value === undefined\n\t                        ? ''\n\t                        : String(value);\n\t                // Tag as side-effect so callers can suppress or echo as needed.\n\t                value = { __whenEffect: 'show', text: textValue } as any;\n\t              } else if (directiveKind === 'output') {\n\t                // Output actions should return empty string (file write is the side effect)\n\t                value = '';\n\t              } else if (directiveKind === 'var') {\n\t                // Variable assignments in when expressions are side effects\n                // They should not count as value-producing matches for 'none' evaluation\n                // But we do need to extract the value for chaining purposes\n                const identifier = singleAction.values?.identifier;\n                if (identifier && Array.isArray(identifier) && identifier[0]) {\n                  const varName = identifier[0].identifier;\n                  if (varName && actionResult.env) {\n                    try {\n                      const variable = actionResult.env.getVariable(varName);\n                      if (variable) {\n                        // Return the assigned variable's raw value, not the Variable wrapper\n                        const { extractVariableValue } = await import('../utils/variable-resolution');\n                        const variableValue = await extractVariableValue(variable, actionResult.env);\n                        value = variableValue as any;\n                      }\n                    } catch (e) {\n                      // If we can't get the variable value, fall back to empty string\n                      logger.debug('Could not get variable value for when expression:', { varName, error: e });\n                    }\n                  }\n                }\n                // Don't count this as a value-producing match\n                // Variable assignments are side effects, not return values\n              }\n            }\n          }\n          \n          // Apply tail modifiers if present\n          if (node.withClause && node.withClause.pipes) {\n            value = await applyTailModifiers(value, node.withClause.pipes, executionEnv);\n          }\n          \n          // Merge variable assignments from this action back into the\n          // accumulated environment so subsequent actions can see them.\n          // We use mergeChild to merge variables; since actions are evaluated\n          // with isExpression=true, no user-facing nodes are produced.\n          accumulatedEnv.mergeChild(executionEnv);\n\n          if (value && typeof value === 'object' && '__whileControl' in (value as Record<string, unknown>)) {\n            return buildResult(value, accumulatedEnv);\n          }\n\n          // In \"first\" mode, return immediately after first match\n          if (isFirstMode) {\n            return buildResult(value, accumulatedEnv);\n          }\n\n          // For bare when, save the value and continue evaluating\n          lastMatchValue = value;\n          \n          // Check if this is a variable assignment (which shouldn't count as value-producing)\n          if (Array.isArray(pair.action) && pair.action.length === 1) {\n            const singleAction = pair.action[0];\n            if (singleAction && typeof singleAction === 'object' && \n                singleAction.type === 'Directive' && singleAction.kind === 'var') {\n              // Variable assignment - don't mark as value-producing\n              // The value is just for internal chaining, not a return value\n            } else {\n              hasValueProducingMatch = true;  // This action produced a real value\n            }\n          } else {\n            hasValueProducingMatch = true;  // Multi-action or non-directive action produced a value\n          }\n          \n          // Continue to evaluate other matching conditions\n        } catch (actionError) {\n          throw new MlldWhenExpressionError(\n            `Error evaluating action for condition ${i + 1}: ${actionError.message}`,\n            node.location,\n            { conditionIndex: i, phase: 'action', originalError: actionError }\n          );\n        }\n      }\n    } catch (conditionError) {\n      // Let the error propagate - it's expected in retry scenarios\n      \n      // Collect condition errors but continue evaluating\n      errors.push(new MlldWhenExpressionError(\n        `Error evaluating condition ${i + 1}: ${conditionError.message}`,\n        node.location,\n        { conditionIndex: i, phase: 'condition', originalError: conditionError }\n      ));\n    }\n  }\n  \n  // Second pass: Evaluate none conditions if no value-producing conditions matched\n  if (!hasValueProducingMatch && !denyMode) {\n    for (let i = 0; i < node.conditions.length; i++) {\n      const entry = node.conditions[i];\n\n      // Skip let assignments in second pass (already processed)\n      if (isLetAssignment(entry)) {\n        continue;\n      }\n\n      const pair = entry;\n\n      // Only process none conditions in second pass\n      if (!(pair.condition.length === 1 && isNoneCondition(pair.condition[0]))) {\n        continue;\n      }\n      \n      if (!pair.action || pair.action.length === 0) {\n        // No action for this none condition - continue to next\n        continue;\n      }\n      \n      try {\n        // Evaluate the action for none condition\n        const actionEnv = accumulatedEnv.createChild();\n        // FIXED: Suppress side effects in when expressions used in /exe functions\n        // Side effects should be handled by the calling context (e.g., /show @func())\n        const actionResult = await evaluate(pair.action, actionEnv, context);\n        \n        let value = actionResult.value;\n        value = await normalizeActionValue(value, actionEnv);\n        \n        // Apply tail modifiers if present\n        if (node.withClause && node.withClause.pipes) {\n          value = await applyTailModifiers(value, node.withClause.pipes, actionResult.env);\n        }\n        \n        // Merge variable assignments from this none-action into accumulator\n        accumulatedEnv.mergeChild(actionEnv);\n\n        // In \"first\" mode, return immediately after first none match\n          if (isFirstMode) {\n            return buildResult(value, accumulatedEnv);\n          }\n\n        // For bare when, save the none value and continue\n        lastNoneValue = value;\n        hasMatch = true;\n      } catch (actionError) {\n        throw new MlldWhenExpressionError(\n          `Error evaluating none action for condition ${i + 1}: ${actionError.message}`,\n          node.location,\n          { conditionIndex: i, phase: 'action', originalError: actionError }\n        );\n      }\n    }\n    \n    // If we had none matches, use the last none value\n    if (lastNoneValue !== null) {\n      lastMatchValue = lastNoneValue;\n    }\n  }\n  \n  // If we had any matches, return the last match value with accumulated environment\n  if (hasMatch) {\n    return buildResult(lastMatchValue, accumulatedEnv);\n  }\n  \n  // If we collected errors and no condition matched, report them\n  if (errors.length > 0) {\n    throw new MlldWhenExpressionError(\n      `When expression evaluation failed with ${errors.length} condition errors`,\n      node.location,\n      { errors }\n    );\n  }\n  \n  // No conditions matched - return null\n  return buildResult(null, accumulatedEnv);\n}\n\n/**\n * Apply tail modifiers (pipeline operations) to a value\n */\nasync function applyTailModifiers(\n  value: unknown,\n  pipes: BaseMlldNode[],\n  env: Environment\n): Promise<unknown> {\n  let result = value;\n  \n  for (const pipe of pipes) {\n    // Create a child environment with the current value as pipeline input\n    const pipeEnv = env.createChild();\n    \n    // Set up pipeline input variable\n    const { createStructuredValueVariable } = await import('@core/types/variable');\n    const structuredInput = ensureStructuredValue(result, undefined, String(result));\n    const pipelineVar = createStructuredValueVariable(\n      '_pipelineInput',\n      structuredInput,\n      { directive: 'var', syntax: 'reference', hasInterpolation: false, isMultiLine: false },\n      { internal: { isPipelineInput: true, pipelineStage: 0 } }\n    );\n    \n    pipeEnv.setVariable('_pipelineInput', pipelineVar);\n    \n    // Evaluate the pipe operation\n    const pipeResult = await evaluate(pipe, pipeEnv);\n    result = pipeResult.value;\n  }\n  \n  return result;\n}\n\n\n/**\n * Peek at the type of a when expression without full evaluation\n * Used for type inference in var assignments\n */\nexport async function peekWhenExpressionType(\n  node: WhenExpressionNode,\n  env: Environment\n): Promise<import('@core/types/variable').VariableTypeDiscriminator> {\n  // Analyze action types without evaluation\n  const actionTypes = new Set<import('@core/types/variable').VariableTypeDiscriminator>();\n  \n  for (const entry of node.conditions) {\n    // Skip let assignments - they don't produce action types\n    if (isLetAssignment(entry)) {\n      continue;\n    }\n\n    const pair = entry;\n    if (pair.action && pair.action.length > 0) {\n      // Simple heuristic based on first node type\n      const firstNode = pair.action[0];\n      \n      if (firstNode.type === 'Text') {\n        actionTypes.add('simple-text');\n      } else if (firstNode.type === 'Literal') {\n        const literal = firstNode as any;\n        if (typeof literal.value === 'number') {\n          actionTypes.add('primitive');\n        } else if (typeof literal.value === 'boolean') {\n          actionTypes.add('primitive');\n        } else if (literal.value === null) {\n          actionTypes.add('primitive');\n        }\n      } else if (firstNode.type === 'object') {\n        actionTypes.add('object');\n      } else if (firstNode.type === 'array') {\n        actionTypes.add('array');\n      } else if (firstNode.type === 'Directive') {\n        // Directives in expressions typically return computed values\n        actionTypes.add('computed');\n      } else {\n        // Default to computed for complex expressions\n        actionTypes.add('computed');\n      }\n    }\n  }\n  \n  // If all actions have same type, use that\n  if (actionTypes.size === 1) {\n    return Array.from(actionTypes)[0];\n  }\n  \n  // Mixed types or unknown - use computed\n  return 'computed';\n}\n","import type { ForDirective, ForExpression, Environment, ArrayVariable, Variable, FieldAccessNode, SourceLocation } from '@core/types';\nimport { evaluate, type EvalResult } from '../core/interpreter';\nimport { FieldAccessError, MlldDirectiveError } from '@core/errors';\nimport { toIterable } from './for-utils';\nimport { getParallelLimit, runWithConcurrency } from '@interpreter/utils/parallel';\nimport { RateLimitRetry, isRateLimitError } from '../eval/pipeline/rate-limit-retry';\nimport { createArrayVariable, createObjectVariable, createPrimitiveVariable, createSimpleTextVariable } from '@core/types/variable';\nimport { isVariable, extractVariableValue } from '../utils/variable-resolution';\nimport { VariableImporter } from './import/VariableImporter';\nimport { logger } from '@core/utils/logger';\nimport { DebugUtils } from '../env/DebugUtils';\nimport { isLoadContentResult } from '@core/types/load-content';\nimport {\n  asData,\n  asText,\n  isStructuredValue,\n  looksLikeJsonString,\n  normalizeWhenShowEffect\n} from '../utils/structured-value';\nimport { materializeDisplayValue } from '../utils/display-materialization';\nimport { accessFields } from '../utils/field-access';\nimport { inheritExpressionProvenance } from '@core/types/provenance/ExpressionProvenance';\nimport { evaluateWhenExpression } from './when-expression';\nimport { isAugmentedAssignment, isLetAssignment } from '@core/types/when';\nimport { evaluateAugmentedAssignment, evaluateLetAssignment } from './when';\n\ninterface ForIterationError {\n  index: number;\n  key?: string | number | null;\n  message: string;\n  error: string;\n  value?: unknown;\n}\n\n// Check if an object looks like file content data (e.g., from glob iteration)\nfunction looksLikeFileData(value: unknown): value is Record<string, unknown> & { content: string; filename?: string; relative?: string; absolute?: string } {\n  if (!value || typeof value !== 'object') return false;\n  const obj = value as Record<string, unknown>;\n  // Must have content (the file's text content)\n  if (typeof obj.content !== 'string') return false;\n  // Should have at least one file path property\n  return typeof obj.filename === 'string' || typeof obj.relative === 'string' || typeof obj.absolute === 'string';\n}\n\n// Helper to ensure a value is wrapped as a Variable\nfunction ensureVariable(name: string, value: unknown, env: Environment): Variable {\n  // If already a Variable, return as-is\n  if (isVariable(value)) {\n    return value;\n  }\n\n  // Special handling for LoadContentResult objects and StructuredValue arrays\n  // These need to be preserved as objects with their special metadata\n  if (isLoadContentResult(value)) {\n    const variable = createObjectVariable(\n      name,\n      value,\n      false, // Not complex - it's already evaluated\n      {\n        directive: 'var',\n        syntax: 'object',\n        hasInterpolation: false,\n        isMultiLine: false\n      },\n      {\n        isLoadContentResult: true,\n        source: 'for-loop'\n      }\n    );\n    // Preserve file metadata in .mx so @f.mx.relative etc. works\n    variable.mx = {\n      ...(variable.mx ?? {}),\n      filename: value.filename,\n      relative: value.relative,\n      absolute: value.absolute,\n      ext: (value as any).ext ?? (value as any)._extension,\n      tokest: (value as any).tokest ?? (value as any)._metrics?.tokest,\n      tokens: (value as any).tokens ?? (value as any)._metrics?.tokens\n    };\n    return variable;\n  }\n\n  if (isStructuredValue(value)) {\n    // For StructuredValue items (both arrays and individual items like glob file entries),\n    // preserve the .mx metadata from the StructuredValue\n    const variable = createObjectVariable(\n      name,\n      value,\n      false, // Not complex - it's already evaluated\n      {\n        directive: 'var',\n        syntax: 'object',\n        hasInterpolation: false,\n        isMultiLine: false\n      },\n      {\n        arrayType: value.type === 'array' ? 'structured-value-array' : undefined,\n        source: 'for-loop'\n      }\n    );\n    // Preserve the StructuredValue's .mx metadata on the Variable\n    // This ensures file metadata (relative, absolute, filename, etc.) is accessible\n    if (value.mx) {\n      variable.mx = { ...value.mx };\n    }\n    return variable;\n  }\n\n  // Check if this looks like file data (from normalizeIterableValue stripping StructuredValue wrapper)\n  // If so, copy file metadata properties to .mx so @f.mx.relative etc. works\n  if (looksLikeFileData(value)) {\n    const importer = new VariableImporter();\n    const variable = importer.createVariableFromValue(name, value, 'for-loop', undefined, { env });\n    // Copy file metadata to .mx\n    variable.mx = {\n      ...(variable.mx ?? {}),\n      filename: value.filename,\n      relative: value.relative,\n      absolute: value.absolute,\n      ext: (value as any).ext,\n      tokest: (value as any).tokest,\n      tokens: (value as any).tokens\n    };\n    return variable;\n  }\n\n  // Otherwise, create a Variable from the value\n  const importer = new VariableImporter();\n  return importer.createVariableFromValue(name, value, 'for-loop', undefined, { env });\n}\n\nfunction formatFieldPath(fields?: FieldAccessNode[]): string | null {\n  if (!fields || fields.length === 0) {\n    return null;\n  }\n  const parts: string[] = [];\n  for (const field of fields) {\n    const value = field.value;\n    switch (field.type) {\n      case 'field':\n      case 'stringIndex':\n      case 'bracketAccess':\n      case 'numericField':\n        parts.push(typeof value === 'number' ? String(value) : String(value ?? ''));\n        break;\n      case 'arrayIndex':\n      case 'variableIndex':\n        parts.push(`[${typeof value === 'number' ? value : String(value ?? '')}]`);\n        break;\n      case 'arraySlice':\n        parts.push(`[${field.start ?? ''}:${field.end ?? ''}]`);\n        break;\n      case 'arrayFilter':\n        parts.push('[?]');\n        break;\n      default:\n        parts.push(String(value ?? ''));\n        break;\n    }\n  }\n\n  return parts\n    .map((part, index) => (part.startsWith('[') || index === 0 ? part : `.${part}`))\n    .join('');\n}\n\nfunction enhanceFieldAccessError(\n  error: unknown,\n  options: { fieldPath?: string | null; varName: string; index: number; key: string | null; sourceLocation?: SourceLocation }\n): unknown {\n  if (!(error instanceof FieldAccessError)) {\n    return error;\n  }\n  const pathSuffix = options.fieldPath ? `.${options.fieldPath}` : '';\n  const contextParts: string[] = [];\n  if (options.key !== null && options.key !== undefined) {\n    contextParts.push(`key ${String(options.key)}`);\n  } else if (options.index >= 0) {\n    contextParts.push(`index ${options.index}`);\n  }\n  const context = contextParts.length > 0 ? ` (${contextParts.join(', ')})` : '';\n  const message = `${error.message} in for binding @${options.varName}${pathSuffix}${context}`;\n  const enhancedDetails = {\n    ...(error.details || {}),\n    iterationIndex: options.index,\n    iterationKey: options.key\n  };\n  return new FieldAccessError(message, enhancedDetails, {\n    cause: error,\n    sourceLocation: (error as any).sourceLocation ?? options.sourceLocation\n  });\n}\n\nfunction withIterationMxKey(variable: Variable, key: unknown): Variable {\n  if (key === null || typeof key === 'undefined') {\n    return variable;\n  }\n  if (typeof key !== 'string' && typeof key !== 'number') {\n    return variable;\n  }\n  return {\n    ...variable,\n    mx: { ...(variable.mx ?? {}), key }\n  };\n}\n\nfunction formatIterationError(error: unknown): string {\n  if (error instanceof Error) {\n    let message = error.message;\n    // Strip directive wrapper noise for user-facing markers\n    if (message.startsWith('Directive error (')) {\n      const prefixEnd = message.indexOf(': ');\n      if (prefixEnd >= 0) {\n        message = message.slice(prefixEnd + 2);\n      }\n      const lineIndex = message.indexOf(' at line ');\n      if (lineIndex >= 0) {\n        message = message.slice(0, lineIndex);\n      }\n    }\n    return message;\n  }\n  if (typeof error === 'string') return error;\n  try {\n    return JSON.stringify(error);\n  } catch {\n    return String(error);\n  }\n}\n\nfunction resetForErrorsContext(env: Environment, errors: ForIterationError[]): void {\n  const mxManager = env.getContextManager?.();\n  if (!mxManager) return;\n  while (mxManager.popGenericContext('for')) {\n    // clear previous loop context\n  }\n  mxManager.pushGenericContext('for', { errors, timestamp: Date.now() });\n  mxManager.setLatestErrors(errors);\n}\n\nfunction findVariableOwner(env: Environment, name: string): Environment | undefined {\n  let current: Environment | undefined = env;\n  while (current) {\n    if (current.getCurrentVariables().has(name)) return current;\n    current = current.getParent();\n  }\n  return undefined;\n}\n\nfunction isDescendantEnvironment(env: Environment, ancestor: Environment): boolean {\n  let current: Environment | undefined = env;\n  while (current) {\n    if (current === ancestor) return true;\n    current = current.getParent();\n  }\n  return false;\n}\n\nexport async function evaluateForDirective(\n  directive: ForDirective,\n  env: Environment\n): Promise<EvalResult> {\n  const varNode = directive.values.variable[0];\n  const varName = varNode.identifier;\n  const varFields = varNode.fields;\n  const fieldPathString = formatFieldPath(varFields);\n  \n  // Debug support\n  const debugEnabled = process.env.DEBUG_FOR === '1' || process.env.DEBUG_FOR === 'true' || process.env.MLLD_DEBUG === 'true';\n\n  // Trace support\n  env.pushDirective('/for', `@${varName} in ...`, directive.location);\n\n  try {\n    // Evaluate source collection\n    // The source is an array containing the actual source node\n    const sourceNode = Array.isArray(directive.values.source) \n      ? directive.values.source[0] \n      : directive.values.source;\n    \n    const sourceResult = await evaluate(sourceNode, env);\n    const sourceValue = sourceResult.value;\n    const iterable = toIterable(sourceValue);\n\n    if (!iterable) {\n      const receivedType = typeof sourceValue;\n      const preview = (() => {\n        try {\n          if (receivedType === 'object') return JSON.stringify(sourceValue)?.slice(0, 120);\n          return String(sourceValue)?.slice(0, 120);\n        } catch { return String(sourceValue); }\n      })();\n      throw new MlldDirectiveError(\n        `Type mismatch: /for expects an array. Received: ${receivedType}${preview ? ` (${preview})` : ''}`,\n        'for',\n        { location: directive.location, context: { expected: 'array', receivedType } }\n      );\n    }\n\n    // Determine parallel options (directive-specified or inherited from parent scope)\n    const specified = (directive.values as any).forOptions as { parallel?: boolean; cap?: number; rateMs?: number } | undefined;\n    const inherited = (env as any).__forOptions as typeof specified | undefined;\n    const effective = specified ?? inherited;\n\n    const iterableArray = Array.from(iterable);\n    const forErrors = effective?.parallel ? ([] as ForIterationError[]) : null;\n    if (forErrors) {\n      resetForErrorsContext(env, forErrors);\n    }\n\n    const runOne = async (entry: [any, any], idx: number) => {\n      const [key, value] = entry;\n      const iterationRoot = env.createChildEnvironment();\n      if (effective?.parallel) {\n        (iterationRoot as any).__parallelIsolationRoot = iterationRoot;\n      }\n      let childEnv = iterationRoot;\n      // Inherit forOptions for nested loops if set\n      if (effective) (childEnv as any).__forOptions = effective;\n      let derivedValue: unknown;\n      if (varFields && varFields.length > 0) {\n        try {\n          const accessed = await accessFields(value, varFields, {\n            env: childEnv,\n            preserveContext: true,\n            sourceLocation: varNode.location\n          });\n          derivedValue = (accessed as any)?.value ?? accessed;\n          inheritExpressionProvenance(derivedValue, value);\n        } catch (error) {\n          throw enhanceFieldAccessError(error, {\n            fieldPath: fieldPathString,\n            varName,\n            index: idx,\n            key: key ?? null,\n            sourceLocation: varNode.location\n          }) as Error;\n        }\n      }\n      const iterationVar = ensureVariable(varName, value, env);\n      childEnv.setVariable(varName, withIterationMxKey(iterationVar, key));\n      if (typeof derivedValue !== 'undefined' && fieldPathString) {\n        const derivedVar = ensureVariable(`${varName}.${fieldPathString}`, derivedValue, env);\n        childEnv.setVariable(`${varName}.${fieldPathString}`, derivedVar);\n      }\n      if (key !== null && typeof key === 'string') {\n        const keyVar = ensureVariable(`${varName}_key`, key, env);\n        childEnv.setVariable(`${varName}_key`, keyVar);\n      }\n\n      const actionNodes = directive.values.action;\n      const retry = new RateLimitRetry();\n      while (true) {\n        try {\n          if (directive.meta?.actionType === 'block') {\n            let blockEnv = childEnv;\n            for (const actionNode of actionNodes) {\n              if (isLetAssignment(actionNode)) {\n                blockEnv = await evaluateLetAssignment(actionNode, blockEnv);\n              } else if (isAugmentedAssignment(actionNode)) {\n                if (effective?.parallel) {\n                  const owner = findVariableOwner(blockEnv, actionNode.identifier);\n                  if (!owner || !isDescendantEnvironment(owner, iterationRoot)) {\n                    throw new MlldDirectiveError(\n                      `Parallel for block cannot mutate outer variable @${actionNode.identifier}.`,\n                      'for',\n                      { location: actionNode.location }\n                    );\n                  }\n                }\n                blockEnv = await evaluateAugmentedAssignment(actionNode, blockEnv);\n              } else if (actionNode.type === 'WhenExpression' && actionNode.meta?.modifier !== 'first') {\n                const nodeWithFirst = {\n                  ...actionNode,\n                  meta: { ...(actionNode.meta || {}), modifier: 'first' as const }\n                };\n                const actionResult = await evaluateWhenExpression(nodeWithFirst as any, blockEnv);\n                blockEnv = actionResult.env || blockEnv;\n              } else {\n                const actionResult = await evaluate(actionNode, blockEnv);\n                blockEnv = actionResult.env || blockEnv;\n              }\n            }\n            childEnv = blockEnv;\n          } else {\n            let actionResult: any = { value: undefined, env: childEnv };\n            for (const actionNode of actionNodes) {\n              if (actionNode.type === 'WhenExpression' && actionNode.meta?.modifier !== 'first') {\n                const nodeWithFirst = {\n                  ...actionNode,\n                  meta: { ...(actionNode.meta || {}), modifier: 'first' as const }\n                };\n                actionResult = await evaluateWhenExpression(nodeWithFirst as any, childEnv);\n              } else {\n                actionResult = await evaluate(actionNode, childEnv);\n              }\n              if (actionResult.env) childEnv = actionResult.env;\n            }\n            // Emit bare exec output as effect (legacy behavior)\n            if (\n              directive.values.action.length === 1 &&\n              directive.values.action[0].type === 'ExecInvocation' &&\n              actionResult.value !== undefined && actionResult.value !== null\n            ) {\n              const materialized = materializeDisplayValue(\n                actionResult.value,\n                undefined,\n                actionResult.value\n              );\n              let outputContent = materialized.text;\n              if (!outputContent.endsWith('\\n')) {\n                outputContent += '\\n';\n              }\n              if (materialized.descriptor) {\n                env.recordSecurityDescriptor(materialized.descriptor);\n              }\n              env.emitEffect('both', outputContent, { source: directive.values.action[0].location });\n            }\n          }\n          retry.reset();\n          break;\n        } catch (err: any) {\n          if (isRateLimitError(err)) {\n            const again = await retry.wait();\n            if (again) continue;\n          }\n          if (forErrors) {\n            forErrors.push({\n              index: idx,\n              key: key ?? null,\n              message: formatIterationError(err),\n              error: formatIterationError(err),\n              value\n            });\n            return;\n          }\n          throw err;\n        }\n      }\n      return;\n    };\n\n    if (effective?.parallel) {\n      const cap = Math.min(effective.cap ?? getParallelLimit(), iterableArray.length);\n      await runWithConcurrency(iterableArray, cap, runOne, { ordered: false, paceMs: effective.rateMs });\n    } else {\n      for (let i = 0; i < iterableArray.length; i++) {\n        await runOne(iterableArray[i], i);\n      }\n    }\n    \n  } finally {\n    env.popDirective();\n  }\n  \n  // For directives don't produce a direct output value\n  return { value: undefined, env };\n}\n\nexport async function evaluateForExpression(\n  expr: ForExpression,\n  env: Environment\n): Promise<ArrayVariable> {\n  const varName = expr.variable.identifier;\n  const varFields = expr.variable.fields;\n  const fieldPathString = formatFieldPath(varFields);\n\n  // Evaluate source collection\n  const sourceResult = await evaluate(expr.source, env, { isExpression: true });\n  const sourceValue = sourceResult.value;\n  const iterable = toIterable(sourceValue);\n\n  if (!iterable) {\n    const receivedType = typeof sourceValue;\n    const preview = (() => {\n      try {\n        if (receivedType === 'object') return JSON.stringify(sourceValue)?.slice(0, 120);\n        return String(sourceValue)?.slice(0, 120);\n      } catch { return String(sourceValue); }\n    })();\n    throw new MlldDirectiveError(\n      `Type mismatch: /for expects an array. Received: ${receivedType}${preview ? ` (${preview})` : ''}`,\n      'for',\n      { location: expr.location, context: { expected: 'array', receivedType } }\n    );\n  }\n\n  const results: unknown[] = [];\n  const errors: ForIterationError[] = [];\n\n  const specified = (expr.meta as any)?.forOptions as { parallel?: boolean; cap?: number; rateMs?: number } | undefined;\n  const inherited = (env as any).__forOptions as typeof specified | undefined;\n  const effective = specified ?? inherited;\n  if (effective?.parallel) {\n    resetForErrorsContext(env, errors);\n  }\n\n  const iterableArray = Array.from(iterable);\n\n  const SKIP = Symbol('skip');\n  const runOne = async (entry: [any, any], idx: number) => {\n    const [key, value] = entry;\n    const iterationRoot = env.createChildEnvironment();\n    if (effective?.parallel) {\n      (iterationRoot as any).__parallelIsolationRoot = iterationRoot;\n    }\n    let childEnv = iterationRoot;\n    if (effective) (childEnv as any).__forOptions = effective;\n    let derivedValue: unknown;\n    if (varFields && varFields.length > 0) {\n      try {\n        const accessed = await accessFields(value, varFields, {\n          env: childEnv,\n          preserveContext: true,\n          sourceLocation: expr.variable.location\n        });\n        derivedValue = (accessed as any)?.value ?? accessed;\n        inheritExpressionProvenance(derivedValue, value);\n      } catch (error) {\n        throw enhanceFieldAccessError(error, {\n          fieldPath: fieldPathString,\n          varName,\n          index: idx,\n          key: key ?? null,\n          sourceLocation: expr.variable.location\n        }) as Error;\n      }\n    }\n    const iterationVar = ensureVariable(varName, value, env);\n    childEnv.setVariable(varName, withIterationMxKey(iterationVar, key));\n    if (typeof derivedValue !== 'undefined' && fieldPathString) {\n      const derivedVar = ensureVariable(`${varName}.${fieldPathString}`, derivedValue, env);\n      childEnv.setVariable(`${varName}.${fieldPathString}`, derivedVar);\n    }\n    if (key !== null && typeof key === 'string') {\n      const keyVar = ensureVariable(`${varName}_key`, key, env);\n      childEnv.setVariable(`${varName}_key`, keyVar);\n    }\n    try {\n      let exprResult: unknown = null;\n      if (Array.isArray(expr.expression) && expr.expression.length > 0) {\n        let nodesToEvaluate = expr.expression;\n        if (\n          expr.expression.length === 1 &&\n          (expr.expression[0] as any).content &&\n          (expr.expression[0] as any).wrapperType &&\n          !(expr.expression[0] as any).hasInterpolation\n        ) {\n          nodesToEvaluate = (expr.expression[0] as any).content;\n        }\n\n        const evaluateSequence = async (nodes: unknown[], startEnv: Environment): Promise<EvalResult> => {\n          let currentEnv = startEnv;\n          let lastResult: EvalResult = { value: undefined, env: currentEnv };\n\n          for (const node of nodes) {\n            if (isLetAssignment(node as any)) {\n              currentEnv = await evaluateLetAssignment(node as any, currentEnv);\n              lastResult = { value: undefined, env: currentEnv };\n              continue;\n            }\n\n            if (isAugmentedAssignment(node as any)) {\n              currentEnv = await evaluateAugmentedAssignment(node as any, currentEnv);\n              lastResult = { value: undefined, env: currentEnv };\n              continue;\n            }\n\n            if ((node as any)?.type === 'WhenExpression' && (node as any).meta?.modifier !== 'first') {\n              const nodeWithFirst = {\n                ...(node as any),\n                meta: { ...(((node as any).meta || {}) as Record<string, unknown>), modifier: 'first' as const }\n              };\n              lastResult = await evaluateWhenExpression(nodeWithFirst as any, currentEnv);\n              currentEnv = lastResult.env || currentEnv;\n              continue;\n            }\n\n            lastResult = await evaluate(node as any, currentEnv, { isExpression: true });\n            currentEnv = lastResult.env || currentEnv;\n          }\n\n          return { value: lastResult.value, env: currentEnv };\n        };\n\n        const result = await evaluateSequence(nodesToEvaluate, childEnv);\n\n        if (result.env) childEnv = result.env;\n        let branchValue = result?.value;\n        if (isStructuredValue(branchValue)) {\n          try {\n            branchValue = asData(branchValue);\n          } catch {\n            branchValue = asText(branchValue);\n          }\n        }\n        if (branchValue === 'skip') {\n          return SKIP as any;\n        }\n        if (isVariable(branchValue)) {\n          exprResult = await extractVariableValue(branchValue, childEnv);\n        } else {\n          exprResult = branchValue;\n        }\n\n        // Preserve directive-produced text (e.g., show/run) when they tag side effects\n        exprResult = normalizeWhenShowEffect(exprResult).normalized;\n\n        if (typeof exprResult === 'string' && looksLikeJsonString(exprResult)) {\n          try {\n            exprResult = JSON.parse(exprResult.trim());\n          } catch {\n            // keep original string if parsing fails\n          }\n        }\n      }\n      return exprResult as any;\n    } catch (error) {\n      const message = formatIterationError(error);\n      const marker: ForIterationError = {\n        index: idx,\n        key: key ?? null,\n        message,\n        error: message,\n        value\n      };\n      errors.push(marker);\n      if (effective?.parallel) {\n        return marker as any;\n      }\n      return null as any;\n    }\n  };\n\n  if (effective?.parallel) {\n    const cap = Math.min(effective.cap ?? getParallelLimit(), iterableArray.length);\n    const orderedResults = await runWithConcurrency(iterableArray, cap, runOne, { ordered: true, paceMs: effective.rateMs });\n    for (const r of orderedResults) if (r !== SKIP) results.push(r);\n  } else {\n    for (let i = 0; i < iterableArray.length; i++) {\n      const r = await runOne(iterableArray[i], i);\n      if (r !== SKIP) results.push(r);\n    }\n  }\n\n  let finalResults: unknown = results;\n  const batchPipelineConfig = expr.meta?.batchPipeline;\n  const batchStages = Array.isArray(batchPipelineConfig)\n    ? batchPipelineConfig\n    : batchPipelineConfig?.pipeline;\n\n  if (batchStages && batchStages.length > 0) {\n    const { processPipeline } = await import('./pipeline/unified-processor');\n    const batchInput = createArrayVariable(\n      'for-batch-input',\n      results,\n      false,\n      {\n        directive: 'for',\n        syntax: 'expression',\n        hasInterpolation: false,\n        isMultiLine: false\n      },\n      { isBatchInput: true }\n    );\n\n    try {\n      const pipelineResult = await processPipeline({\n        value: batchInput,\n        env,\n        pipeline: batchStages,\n        identifier: `for-batch-${expr.variable.identifier}`,\n        location: expr.location,\n        isRetryable: false\n      });\n\n      if (isStructuredValue(pipelineResult)) {\n        finalResults = asData(pipelineResult);\n      } else if (isVariable(pipelineResult)) {\n        finalResults = await extractVariableValue(pipelineResult, env);\n      } else {\n        finalResults = pipelineResult;\n      }\n    } catch (error) {\n      logger.warn(\n        `Batch pipeline failed for for-expression: ${error instanceof Error ? error.message : String(error)}`\n      );\n      errors.push({\n        index: -1,\n        error: error as Error,\n        value: results\n      });\n      finalResults = results;\n    }\n  }\n\n  const variableSource = {\n    directive: 'for',\n    syntax: 'expression',\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n\n  const metadata: Record<string, unknown> = {\n    sourceExpression: expr.expression,\n    iterationVariable: expr.variable.identifier\n  };\n\n  if (batchStages && batchStages.length > 0) {\n    metadata.hadBatchPipeline = true;\n  }\n\n  if (errors.length > 0) {\n    metadata.forErrors = errors;\n  }\n\n  if (Array.isArray(finalResults)) {\n    return createArrayVariable(\n      'for-result',\n      finalResults,\n      false,\n      variableSource,\n      {\n        metadata,\n        internal: {\n          arrayType: 'for-expression-result'\n        }\n      }\n    );\n  }\n\n  if (finalResults === undefined) {\n    return createPrimitiveVariable(\n      'for-result',\n      null,\n      variableSource,\n      { mx: metadata }\n    );\n  }\n\n  if (\n    finalResults === null ||\n    typeof finalResults === 'number' ||\n    typeof finalResults === 'boolean'\n  ) {\n    return createPrimitiveVariable(\n      'for-result',\n      finalResults as number | boolean | null,\n      variableSource,\n      { mx: metadata }\n    );\n  }\n\n  if (typeof finalResults === 'string') {\n    return createSimpleTextVariable(\n      'for-result',\n      finalResults,\n      variableSource,\n      { mx: metadata }\n    );\n  }\n\n  if (typeof finalResults === 'object') {\n    return createObjectVariable(\n      'for-result',\n      finalResults,\n      false,\n      variableSource,\n      { mx: metadata }\n    );\n  }\n\n  return createSimpleTextVariable(\n    'for-result',\n    String(finalResults),\n    variableSource,\n    { mx: metadata }\n  );\n}\n","import type { ExportDirectiveNode } from '@core/types';\nimport type { VariableReferenceNode } from '@core/types/variable';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport { ExportManifest, type ExportManifestEntry } from './import/ExportManifest';\nimport { astLocationToSourceLocation } from '@core/types';\n\nexport async function evaluateExport(\n  directive: ExportDirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  const exportNodes = (directive.values?.exports ?? []) as VariableReferenceNode[];\n\n    const filePath = env.getCurrentFilePath();\n    const entries: ExportManifestEntry[] = [];\n    let hasWildcard = false;\n    const guardRegistry = env.getGuardRegistry();\n\n    for (const node of exportNodes) {\n      const identifier = node?.identifier ?? '';\n      if (!identifier) continue;\n\n      if (identifier === '*') {\n        hasWildcard = true;\n        continue;\n      }\n\n      const location = astLocationToSourceLocation(node?.location, filePath);\n      const isGuard = guardRegistry.getByName(identifier) !== undefined;\n      const kind = isGuard ? 'guard' : 'variable';\n      entries.push({ name: identifier, location, kind });\n    }\n\n    if (hasWildcard) {\n      // Reset the manifest so downstream logic falls back to the auto-export path.\n      env.setExportManifest(null);\n      return { value: undefined, env };\n    }\n\n    if (entries.length === 0) {\n      return { value: undefined, env };\n    }\n\n    let manifest = env.getExportManifest();\n    if (!manifest) {\n      // Lazily create the manifest the first time /export appears in the module.\n      manifest = new ExportManifest();\n      env.setExportManifest(manifest);\n    }\n\n  manifest.add(entries);\n\n  const emitter = env as any;\n  if (typeof emitter.emitSDKEvent === 'function') {\n    for (const entry of entries) {\n      emitter.emitSDKEvent({\n        type: 'debug:export:registered',\n        name: entry.name,\n        timestamp: Date.now()\n      });\n    }\n  }\n\n  return { value: undefined, env };\n}\n","import type { GuardDirectiveNode } from '@core/types/guard';\nimport type { DirectiveNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport { GuardRegistry } from '../guards/GuardRegistry';\n\nexport async function evaluateGuard(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  const guardNode = directive as GuardDirectiveNode;\n  const registry = env.getGuardRegistry();\n  registry.register(guardNode, directive.location ?? null);\n  return { value: undefined, env };\n}\n","import { MlldInterpreterError } from '@core/errors';\nimport type { PackageRequirement, PackageRequirementMap } from '@core/registry/types';\nimport { parseVersionSpecifier } from '@core/registry/utils/ModuleNeeds';\n\nconst PACKAGE_ECOSYSTEM_ALIASES: Record<string, string> = {\n  node: 'node',\n  js: 'node',\n  python: 'python',\n  py: 'python',\n  ruby: 'ruby',\n  rb: 'ruby',\n  go: 'go',\n  rust: 'rust'\n};\n\nconst BOOLEAN_CAPABILITY_ALIASES: Record<string, string> = {\n  sh: 'sh',\n  bash: 'sh',\n  network: 'network',\n  net: 'network',\n  filesystem: 'filesystem',\n  fs: 'filesystem'\n};\n\nexport interface CommandNeedDetail {\n  list?: string[];\n  methods?: string[];\n  subcommands?: string[];\n  flags?: string[];\n  wildcard?: boolean;\n}\n\nexport type CommandNeeds =\n  | { type: 'all' }\n  | { type: 'list'; commands: string[] }\n  | { type: 'map'; entries: Record<string, CommandNeedDetail> };\n\nexport interface NeedsDeclaration {\n  packages: PackageRequirementMap;\n  cmd?: CommandNeeds;\n  sh?: boolean;\n  network?: boolean;\n  filesystem?: boolean;\n}\n\nexport interface WantsTier {\n  tier: string;\n  why?: string;\n  needs: NeedsDeclaration;\n}\n\nexport interface PolicyCapabilities {\n  allowAll?: boolean;\n  cmd?: CommandNeeds;\n  sh?: boolean;\n  network?: boolean;\n  filesystem?: boolean;\n}\n\nexport const ALLOW_ALL_POLICY: PolicyCapabilities = Object.freeze({\n  allowAll: true,\n  cmd: { type: 'all' },\n  sh: true,\n  network: true,\n  filesystem: true\n});\n\nexport function normalizeNeedsDeclaration(raw: unknown, context: string = 'needs'): NeedsDeclaration {\n  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {\n    throw new MlldInterpreterError(`/${context} expects an object`, {\n      code: 'INVALID_NEEDS_DECLARATION'\n    });\n  }\n\n  const rawObj = raw as Record<string, unknown>;\n  const result: NeedsDeclaration = {\n    packages: {}\n  };\n\n  const commandNeeds = normalizeCommandNeeds(rawObj.cmd);\n  const bareCommands = normalizeBareCommands(rawObj.__commands);\n\n  for (const [key, value] of Object.entries(rawObj)) {\n    if (key === 'cmd' || key === '__commands') {\n      continue;\n    }\n\n    const packageKey = PACKAGE_ECOSYSTEM_ALIASES[key];\n    if (packageKey) {\n      const normalized = normalizePackages(value, packageKey, context);\n      const existing = result.packages[packageKey] || [];\n      const merged = [...existing];\n      for (const pkg of normalized) {\n        if (!merged.find(p => p.name === pkg.name && p.specifier === pkg.specifier)) {\n          merged.push(pkg);\n        }\n      }\n      result.packages[packageKey] = merged;\n      continue;\n    }\n\n    const booleanKey = BOOLEAN_CAPABILITY_ALIASES[key];\n    if (booleanKey === 'sh') {\n      result.sh = Boolean(value === undefined ? true : value) || result.sh === true;\n      continue;\n    }\n    if (booleanKey === 'network') {\n      result.network = Boolean(value === undefined ? true : value) || result.network === true;\n      continue;\n    }\n    if (booleanKey === 'filesystem') {\n      result.filesystem = Boolean(value === undefined ? true : value) || result.filesystem === true;\n      continue;\n    }\n\n    throw new MlldInterpreterError(`/${context} contains unsupported key '${key}'`, {\n      code: 'INVALID_NEEDS_KEY'\n    });\n  }\n\n  if (commandNeeds) {\n    result.cmd = commandNeeds;\n  }\n\n  if (bareCommands.length > 0) {\n    result.cmd = mergeCommandNeeds(\n      result.cmd,\n      { type: 'list', commands: bareCommands }\n    );\n  }\n\n  return result;\n}\n\nexport function normalizeWantsDeclaration(raw: unknown): WantsTier[] {\n  if (raw === undefined || raw === null) {\n    return [];\n  }\n\n  if (!Array.isArray(raw)) {\n    throw new MlldInterpreterError('/wants expects an array of tier objects', {\n      code: 'INVALID_WANTS_DECLARATION'\n    });\n  }\n\n  return raw.map((entry, index) => {\n    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {\n      throw new MlldInterpreterError(`/wants tier at index ${index} is not an object`, {\n        code: 'INVALID_WANTS_TIER'\n      });\n    }\n\n    const tierObj = entry as Record<string, unknown>;\n    const tierValue = tierObj.tier;\n    if (typeof tierValue !== 'string' || tierValue.trim().length === 0) {\n      throw new MlldInterpreterError(`/wants tier at index ${index} is missing required 'tier'`, {\n        code: 'INVALID_WANTS_TIER'\n      });\n    }\n\n    const { tier, why, ...rest } = tierObj as Record<string, unknown>;\n\n    const needs = normalizeNeedsDeclaration(rest, 'wants');\n    const allowedKeys = new Set([\n      'tier',\n      'why',\n      'cmd',\n      '__commands',\n      ...Object.keys(PACKAGE_ECOSYSTEM_ALIASES),\n      ...Object.keys(BOOLEAN_CAPABILITY_ALIASES)\n    ]);\n    for (const key of Object.keys(tierObj)) {\n      if (!allowedKeys.has(key)) {\n        throw new MlldInterpreterError(`/wants tier '${tierValue}' contains unsupported key '${key}'`, {\n          code: 'INVALID_WANTS_KEY'\n        });\n      }\n    }\n\n    return {\n      tier: tierValue,\n      why: typeof why === 'string' ? why : undefined,\n      needs\n    };\n  });\n}\n\nexport function policySatisfiesNeeds(needs: NeedsDeclaration, policy: PolicyCapabilities): boolean {\n  if (policy.allowAll) {\n    return true;\n  }\n\n  if (needs.sh && policy.sh !== true) {\n    return false;\n  }\n  if (needs.network && policy.network !== true) {\n    return false;\n  }\n  if (needs.filesystem && policy.filesystem !== true) {\n    return false;\n  }\n\n  if (needs.cmd) {\n    if (!policy.cmd) {\n      // No explicit policy, treat as allow all commands when not locked down\n      return true;\n    }\n    if (!commandsAllowed(needs.cmd, policy.cmd)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport function selectWantsTier(\n  wants: WantsTier[],\n  policy: PolicyCapabilities\n): { tier: string; granted: NeedsDeclaration } | null {\n  for (const tier of wants) {\n    if (policySatisfiesNeeds(tier.needs, policy)) {\n      return { tier: tier.tier, granted: tier.needs };\n    }\n  }\n  return null;\n}\n\nexport function mergeNeedsDeclarations(\n  base: NeedsDeclaration | undefined,\n  incoming: NeedsDeclaration\n): NeedsDeclaration {\n  if (!base) {\n    return incoming;\n  }\n\n  const mergedPackages: PackageRequirementMap = { ...(base.packages || {}) };\n  for (const [ecosystem, pkgs] of Object.entries(incoming.packages || {})) {\n    const existing = mergedPackages[ecosystem] || [];\n    const combined = [...existing];\n    for (const pkg of pkgs) {\n      if (!combined.find(p => p.name === pkg.name && p.specifier === pkg.specifier)) {\n        combined.push(pkg);\n      }\n    }\n    mergedPackages[ecosystem] = combined;\n  }\n\n  return {\n    packages: mergedPackages,\n    sh: base.sh || incoming.sh,\n    network: base.network || incoming.network,\n    filesystem: base.filesystem || incoming.filesystem,\n    cmd: mergeCommandNeeds(base.cmd, incoming.cmd)\n  };\n}\n\nfunction normalizeCommandNeeds(raw: unknown): CommandNeeds | undefined {\n  if (raw === undefined || raw === null) {\n    return undefined;\n  }\n\n  // Wildcard support\n  if (raw === '*' || (typeof raw === 'object' && (raw as any).type === 'wildcard')) {\n    return { type: 'all' };\n  }\n\n  if (typeof raw === 'object') {\n    const obj = raw as Record<string, unknown>;\n    if (obj.type === 'list') {\n      const commands = normalizeStringArray((obj as any).items, 'cmd list');\n      return { type: 'list', commands };\n    }\n    if (obj.type === 'map') {\n      const entries = normalizeCommandMap(obj.entries);\n      return { type: 'map', entries };\n    }\n    if (Array.isArray(obj.items)) {\n      const commands = normalizeStringArray(obj.items, 'cmd list');\n      return { type: 'list', commands };\n    }\n    if (obj.entries && typeof obj.entries === 'object') {\n      const entries = normalizeCommandMap(obj.entries as Record<string, unknown>);\n      return { type: 'map', entries };\n    }\n  }\n\n  if (Array.isArray(raw)) {\n    const commands = normalizeStringArray(raw, 'cmd list');\n    return { type: 'list', commands };\n  }\n\n  if (typeof raw === 'string') {\n    return { type: 'list', commands: [raw] };\n  }\n\n  throw new MlldInterpreterError('Invalid /needs cmd declaration', {\n    code: 'INVALID_NEEDS_CMD'\n  });\n}\n\nfunction normalizeBareCommands(raw: unknown): string[] {\n  if (!raw) {\n    return [];\n  }\n  if (Array.isArray(raw)) {\n    return normalizeStringArray(raw, 'command list');\n  }\n  return normalizeStringArray([raw], 'command list');\n}\n\nfunction normalizeStringArray(raw: unknown, label: string): string[] {\n  if (!Array.isArray(raw)) {\n    throw new MlldInterpreterError(`Expected array for ${label}`, {\n      code: 'INVALID_NEEDS_VALUE'\n    });\n  }\n  const values = raw\n    .map(item => {\n      if (typeof item === 'string') {\n        return item;\n      }\n      if (item && typeof item === 'object' && 'toString' in item) {\n        return String(item as any);\n      }\n      throw new MlldInterpreterError(`Expected string entries for ${label}`, {\n        code: 'INVALID_NEEDS_VALUE'\n      });\n    })\n    .map(str => str.trim())\n    .filter(str => str.length > 0);\n  return Array.from(new Set(values));\n}\n\nfunction normalizeCommandMap(raw: unknown): Record<string, CommandNeedDetail> {\n  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {\n    throw new MlldInterpreterError('Invalid command map in /needs', {\n      code: 'INVALID_NEEDS_CMD'\n    });\n  }\n\n  const result: Record<string, CommandNeedDetail> = {};\n  for (const [name, value] of Object.entries(raw as Record<string, unknown>)) {\n    result[name] = normalizeCommandDetail(value);\n  }\n  return result;\n}\n\nfunction normalizeCommandDetail(raw: unknown): CommandNeedDetail {\n  if (raw === '*' || (raw && typeof raw === 'object' && (raw as any).type === 'wildcard')) {\n    return { wildcard: true };\n  }\n\n  if (Array.isArray(raw)) {\n    return { list: normalizeStringArray(raw, 'command detail') };\n  }\n\n  if (raw && typeof raw === 'object') {\n    const obj = raw as Record<string, unknown>;\n    if (obj.type === 'list') {\n      return { list: normalizeStringArray((obj as any).items ?? [], 'command detail') };\n    }\n    if (obj.type === 'detail' && obj.props && typeof obj.props === 'object') {\n      return normalizeCommandDetail((obj as any).props);\n    }\n    const detail: CommandNeedDetail = {};\n    if (obj.methods !== undefined) {\n      detail.methods = normalizeStringArray(obj.methods, 'command methods');\n    }\n    if (obj.subcommands !== undefined) {\n      detail.subcommands = normalizeStringArray(obj.subcommands, 'command subcommands');\n    }\n    if (obj.flags !== undefined) {\n      detail.flags = normalizeStringArray(obj.flags, 'command flags');\n    }\n    if (Object.keys(detail).length === 0) {\n      return { list: [] };\n    }\n    return detail;\n  }\n\n  if (typeof raw === 'string') {\n    return { list: [raw] };\n  }\n\n  throw new MlldInterpreterError('Invalid command detail in /needs', {\n    code: 'INVALID_NEEDS_CMD'\n  });\n}\n\nfunction normalizePackages(raw: unknown, ecosystem: string, context: string): PackageRequirement[] {\n  if (!Array.isArray(raw)) {\n    throw new MlldInterpreterError(`/${context} ${ecosystem} expects an array of packages`, {\n      code: 'INVALID_NEEDS_PACKAGES'\n    });\n  }\n\n  const packages: PackageRequirement[] = [];\n  for (const entry of raw) {\n    if (typeof entry !== 'string') {\n      throw new MlldInterpreterError(`/${context} ${ecosystem} entries must be strings`, {\n        code: 'INVALID_NEEDS_PACKAGES'\n      });\n    }\n    const parsed = parseVersionSpecifier(entry);\n    if (!parsed.name) {\n      throw new MlldInterpreterError(`/${context} ${ecosystem} entry '${entry}' is invalid`, {\n        code: 'INVALID_NEEDS_PACKAGES'\n      });\n    }\n    if (!packages.find(pkg => pkg.name === parsed.name && pkg.specifier === parsed.specifier)) {\n      packages.push(parsed);\n    }\n  }\n  return packages;\n}\n\nfunction commandsAllowed(needs: CommandNeeds, policy: CommandNeeds): boolean {\n  if (policy.type === 'all' || needs.type === 'list' && policy.type === 'all') {\n    return true;\n  }\n\n  if (needs.type === 'all' && policy.type !== 'all') {\n    return false;\n  }\n\n  if (needs.type === 'list') {\n    if (policy.type === 'list') {\n      return needs.commands.every(cmd => policy.commands.includes(cmd));\n    }\n    if (policy.type === 'map') {\n      return needs.commands.every(cmd => Boolean(policy.entries[cmd]));\n    }\n  }\n\n  if (needs.type === 'map') {\n    if (policy.type === 'all') {\n      return true;\n    }\n    if (policy.type === 'list') {\n      return Object.keys(needs.entries).every(cmd => policy.commands.includes(cmd));\n    }\n    if (policy.type === 'map') {\n      return Object.keys(needs.entries).every(cmd => Boolean(policy.entries[cmd]));\n    }\n  }\n\n  return true;\n}\n\nfunction mergeCommandNeeds(base?: CommandNeeds, incoming?: CommandNeeds): CommandNeeds | undefined {\n  if (!base) return incoming;\n  if (!incoming) return base;\n\n  if (base.type === 'all' || incoming.type === 'all') {\n    return { type: 'all' };\n  }\n\n  if (base.type === 'list' && incoming.type === 'list') {\n    const combined = Array.from(new Set([...base.commands, ...incoming.commands]));\n    return { type: 'list', commands: combined };\n  }\n\n  if (base.type === 'map' && incoming.type === 'map') {\n    return { type: 'map', entries: { ...base.entries, ...incoming.entries } };\n  }\n\n  if (base.type === 'map' && incoming.type === 'list') {\n    const entries = { ...base.entries };\n    for (const cmd of incoming.commands) {\n      entries[cmd] = entries[cmd] || { list: [] };\n    }\n    return { type: 'map', entries };\n  }\n\n  if (base.type === 'list' && incoming.type === 'map') {\n    const entries = { ...incoming.entries };\n    for (const cmd of base.commands) {\n      entries[cmd] = entries[cmd] || { list: [] };\n    }\n    return { type: 'map', entries };\n  }\n\n  return incoming;\n}\n","import type { DirectiveNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport {\n  normalizeNeedsDeclaration,\n  normalizeWantsDeclaration,\n  selectWantsTier\n} from '@core/policy/needs';\n\nexport async function evaluateNeeds(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  const needsRaw = (directive.values as any)?.needs ?? {};\n  const needs = normalizeNeedsDeclaration(needsRaw);\n\n  env.recordModuleNeeds(needs);\n\n  return {\n    value: undefined,\n    env,\n    stdout: '',\n    stderr: '',\n    exitCode: 0\n  };\n}\n\nexport async function evaluateWants(\n  directive: DirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  const wantsRaw = (directive.values as any)?.wants ?? [];\n  const wants = normalizeWantsDeclaration(wantsRaw);\n\n  env.recordModuleWants(wants);\n\n  const policy = env.getPolicyCapabilities();\n  const match = selectWantsTier(wants, policy);\n\n  const existingContext = env.getPolicyContext();\n  const policyContext = {\n    tier: match?.tier ?? null,\n    configs: existingContext?.configs ?? {},\n    activePolicies: existingContext?.activePolicies ?? [],\n    ...(existingContext?.environment ? { environment: existingContext.environment } : {})\n  };\n  env.setPolicyContext(policyContext);\n\n  return {\n    value: match?.tier ?? null,\n    env,\n    stdout: '',\n    stderr: '',\n    exitCode: 0\n  };\n}\n","import { GuardError } from '@core/errors/GuardError';\nimport { GuardRetrySignal, isGuardRetrySignal } from '@core/errors/GuardRetrySignal';\nimport type { GuardHint, GuardResult } from '@core/types/guard';\nimport type { GuardContextSnapshot, OperationContext } from '../env/ContextManager';\nimport type { Environment } from '../env/Environment';\nimport { appendFileSync } from 'fs';\n\nconst DEFAULT_GUARD_MAX = 3;\nconst afterRetryDebugEnabled = process.env.DEBUG_AFTER_RETRY === '1';\n\ninterface GuardRetryAttempt {\n  attempt: number;\n  decision: 'retry';\n  hint?: string | null;\n}\n\ninterface GuardRetryState {\n  attempt: number;\n  max: number;\n  history: GuardRetryAttempt[];\n  hintHistory: Array<string | null>;\n}\n\ninterface GuardRetryErrorDetails {\n  guardName?: string | null;\n  guardFilter?: string;\n  scope?: any;\n  operation?: OperationContext;\n  inputPreview?: string | null;\n  outputPreview?: string | null;\n  guardContext?: GuardContextSnapshot;\n  guardResults?: GuardResult[];\n  hints?: GuardHint[];\n}\n\ninterface GuardRetryOptions<T> {\n  env: Environment;\n  execute: () => Promise<T>;\n  operationContext?: OperationContext;\n  sourceRetryable?: boolean;\n}\n\nfunction logAfterRetryDebug(label: string, payload: Record<string, unknown>): void {\n  if (!afterRetryDebugEnabled) {\n    return;\n  }\n  try {\n    console.error(`[after-guard-retry] ${label}`, payload);\n  } catch {\n    // ignore debug logging failures\n  }\n}\n\nfunction extractGuardRetryDetails(error: unknown): GuardRetryErrorDetails {\n  if (!error || typeof error !== 'object') {\n    return {};\n  }\n  const candidate = error as any;\n  const details = (candidate.details as GuardRetryErrorDetails | undefined) ?? {};\n  return {\n    guardName: candidate.guardName ?? details.guardName,\n    guardFilter: candidate.guardFilter ?? details.guardFilter,\n    scope: candidate.scope ?? details.scope,\n    operation: candidate.operation ?? details.operation,\n    inputPreview: candidate.inputPreview ?? details.inputPreview,\n    outputPreview: candidate.outputPreview ?? details.outputPreview,\n    guardContext: candidate.guardContext ?? details.guardContext,\n    guardResults: candidate.guardResults ?? details.guardResults,\n    hints: candidate.hints ?? details.hints\n  };\n}\n\nexport async function runWithGuardRetry<T>(options: GuardRetryOptions<T>): Promise<T> {\n  const state: GuardRetryState = {\n    attempt: 1,\n    max: DEFAULT_GUARD_MAX,\n    history: [],\n    hintHistory: []\n  };\n\n  // Re-evaluate until success or a non-retry error\n  for (;;) {\n    const guardRetryContext = {\n      attempt: state.attempt,\n      try: state.attempt,\n      tries: state.history.map(entry => ({ ...entry })),\n      max: state.max,\n      hintHistory: state.hintHistory.slice()\n    };\n\n    try {\n      return await options.env\n        .getContextManager()\n        .withGenericContext('guardRetry', guardRetryContext, options.execute);\n    } catch (error) {\n      const isRetrySignal =\n        (error instanceof GuardError && error.decision === 'retry') || isGuardRetrySignal(error);\n      const debugPayload = {\n        attempt: state.attempt,\n        isRetrySignal,\n        sourceRetryable: options.sourceRetryable ?? null,\n        pipeline: Boolean(options.env.getPipelineContext())\n      };\n      logAfterRetryDebug('guard retry caught', debugPayload);\n      try {\n        appendFileSync(\n          '/tmp/mlld_guard_retry.log',\n          JSON.stringify(\n            {\n              event: 'caught',\n              ...debugPayload,\n              hint:\n                (error as any)?.retryHint ??\n                extractGuardRetryDetails(error).hints?.[0]?.hint ??\n                (error as GuardError).reason ??\n                null\n            },\n            null,\n            2\n          ) + '\\n'\n        );\n      } catch {\n        // ignore file debug failures\n      }\n      if (!isRetrySignal) {\n        throw error;\n      }\n\n      // Allow pipeline executor to handle retries inside pipelines\n      if (options.env.getPipelineContext()) {\n        const rethrowPayload = {\n          attempt: state.attempt,\n          hint:\n            (error as GuardError).retryHint ??\n            (error as any)?.retryHint ??\n            extractGuardRetryDetails(error).hints?.[0]?.hint ??\n            null\n        };\n        logAfterRetryDebug('rethrow to pipeline executor', rethrowPayload);\n        try {\n          appendFileSync(\n            '/tmp/mlld_guard_retry.log',\n            JSON.stringify({ event: 'rethrow', ...rethrowPayload }, null, 2) + '\\n'\n          );\n        } catch {\n          // ignore file debug failures\n        }\n        throw error;\n      }\n\n      const details = extractGuardRetryDetails(error);\n      const guardContext = details.guardContext;\n      if (typeof guardContext?.max === 'number') {\n        state.max = guardContext.max;\n      }\n      const hint =\n        (error as GuardError).retryHint ??\n        (typeof details.hints?.[0]?.hint === 'string' ? details.hints![0]!.hint : null) ??\n        (error as GuardError).reason ??\n        null;\n      state.history.push({ attempt: state.attempt, decision: 'retry', hint });\n      state.hintHistory.push(hint ?? null);\n      state.attempt += 1;\n\n      if (!options.sourceRetryable) {\n        const denyPayload = {\n          attempt: state.attempt - 1,\n          hint,\n          sourceRetryable: options.sourceRetryable ?? null,\n          guardName: details.guardName ?? guardContext?.name ?? null\n        };\n        logAfterRetryDebug('guard retry denied (non-retryable source)', denyPayload);\n        try {\n          appendFileSync(\n            '/tmp/mlld_guard_retry.log',\n            JSON.stringify({ event: 'deny-non-retryable', ...denyPayload }, null, 2) + '\\n'\n          );\n        } catch {\n          // ignore file debug failures\n        }\n        throw new GuardError({\n          decision: 'deny',\n          guardName: details.guardName ?? guardContext?.name ?? null,\n          guardFilter: details.guardFilter ?? guardContext?.guardFilter,\n          scope: details.scope,\n          operation: details.operation ?? options.operationContext,\n          inputPreview: details.inputPreview ?? null,\n          outputPreview: details.outputPreview ?? null,\n          retryHint: hint,\n          reason: `Cannot retry: ${hint ?? 'source not retryable'}`,\n          guardContext: guardContext ?? undefined,\n          guardResults: details.guardResults,\n          hints: details.hints\n        });\n      }\n\n      if (state.attempt > state.max) {\n        logAfterRetryDebug('guard retry budget exceeded', {\n          attempt: state.attempt - 1,\n          max: state.max,\n          hint,\n          guardName: details.guardName ?? guardContext?.name ?? null\n        });\n        throw new GuardError({\n          decision: 'deny',\n          guardName: details.guardName ?? guardContext?.name ?? null,\n          guardFilter: details.guardFilter ?? guardContext?.guardFilter,\n          scope: details.scope,\n          operation: details.operation ?? options.operationContext,\n          inputPreview: details.inputPreview ?? null,\n          outputPreview: details.outputPreview ?? null,\n          reason: `Guard retry limit exceeded (${state.max})`,\n          guardContext: {\n            ...(guardContext ?? {}),\n            attempt: state.attempt - 1,\n            try: state.attempt - 1,\n            tries: state.history.map(entry => ({ ...entry })),\n            max: state.max\n          } as GuardContextSnapshot,\n          guardResults: details.guardResults,\n          hints: details.hints\n        });\n      }\n    }\n  }\n}\n","import type { PolicyDirectiveNode, PolicyReferenceNode, PolicyUnionExpression } from '@core/types/policy';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport { mergePolicyConfigs, normalizePolicyConfig, type PolicyConfig } from '@core/policy/union';\nimport { MlldInterpreterError } from '@core/errors';\nimport { extractVariableValue } from '../utils/variable-resolution';\nimport { getTextContent } from '../utils/type-guard-helpers';\nimport { createObjectVariable, type VariableSource } from '@core/types/variable';\nimport { astLocationToSourceLocation } from '@core/types';\n\nexport async function evaluatePolicy(\n  directive: PolicyDirectiveNode,\n  env: Environment\n): Promise<EvalResult> {\n  const configs = await evaluateUnionExpression(directive.values.expr, env);\n  const merged = mergePolicyConfigsFromArray(configs);\n\n  const nameNode = directive.values.name?.[0];\n  const policyName = getTextContent(nameNode) || directive.raw?.name;\n  if (!policyName) {\n    throw new MlldInterpreterError('Policy directive is missing a name', {\n      code: 'INVALID_POLICY_NAME'\n    });\n  }\n\n  const source: VariableSource = {\n    directive: 'policy',\n    syntax: 'object',\n    hasInterpolation: false,\n    isMultiLine: false\n  };\n\n  const variable = createObjectVariable(\n    policyName,\n    merged,\n    false,\n    source,\n    {\n      definedAt: astLocationToSourceLocation(directive.location, env.getCurrentFilePath())\n    }\n  );\n\n  env.setVariable(policyName, variable);\n  env.recordPolicyConfig(policyName, merged);\n\n  return {\n    value: merged,\n    env,\n    stdout: '',\n    stderr: '',\n    exitCode: 0\n  };\n}\n\nasync function evaluateUnionExpression(\n  expr: PolicyUnionExpression,\n  env: Environment\n): Promise<PolicyConfig[]> {\n  if (!expr || expr.type !== 'union') {\n    throw new MlldInterpreterError('Only union expressions are supported in /policy', {\n      code: 'INVALID_POLICY_EXPRESSION'\n    });\n  }\n\n  if (!expr.args || expr.args.length === 0) {\n    throw new MlldInterpreterError('Policy union requires at least one reference', {\n      code: 'INVALID_POLICY_EXPRESSION'\n    });\n  }\n\n  const configs: PolicyConfig[] = [];\n  for (const arg of expr.args) {\n    configs.push(await resolvePolicyReference(arg, env));\n  }\n  return configs;\n}\n\nasync function resolvePolicyReference(\n  arg: PolicyReferenceNode,\n  env: Environment\n): Promise<PolicyConfig> {\n  if (!arg || arg.type !== 'ref') {\n    throw new MlldInterpreterError('Unsupported policy expression argument', {\n      code: 'INVALID_POLICY_REFERENCE'\n    });\n  }\n\n  const refName = arg.name;\n  const variable = env.getVariable(refName);\n  if (!variable) {\n    throw new MlldInterpreterError(`Policy reference '@${refName}' is not defined`, {\n      code: 'POLICY_REFERENCE_NOT_FOUND'\n    });\n  }\n\n  const rawValue = await extractVariableValue(variable, env);\n  const candidate = resolvePolicyConfigSource(rawValue);\n  if (!candidate) {\n    throw new MlldInterpreterError(`Policy reference '@${refName}' is not a policy configuration`, {\n      code: 'INVALID_POLICY_REFERENCE'\n    });\n  }\n\n  return normalizePolicyConfig(candidate);\n}\n\nfunction resolvePolicyConfigSource(value: any): PolicyConfig | undefined {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) {\n    return undefined;\n  }\n\n  if (value.config && typeof value.config === 'object') {\n    return value.config as PolicyConfig;\n  }\n\n  return value as PolicyConfig;\n}\n\nfunction mergePolicyConfigsFromArray(configs: PolicyConfig[]): PolicyConfig {\n  return configs.reduce<PolicyConfig | undefined>(\n    (acc, current) => mergePolicyConfigs(acc, current),\n    undefined\n  ) ?? {};\n}\n","import type { DirectiveNode } from '@core/types';\nimport type { Environment } from '../env/Environment';\nimport type { EvalResult, EvaluationContext } from '../core/interpreter';\nimport { getTextContent } from '../utils/type-guard-helpers';\nimport type { OperationContext, PipelineContextSnapshot } from '../env/ContextManager';\nimport type { PolicyDirectiveNode } from '@core/types/policy';\nimport { extractDirectiveInputs } from './directive-inputs';\nimport { getGuardTransformedInputs, handleGuardDecision } from '../hooks/hook-decision-handler';\nimport type { Variable } from '@core/types/variable';\nimport { isVariable } from '../utils/variable-resolution';\n\n// Import specific evaluators\nimport { evaluatePath } from './path';\nimport { evaluateRun } from './run';\nimport { evaluateImport } from './import';\nimport { evaluateWhen } from './when';\nimport { evaluateOutput } from './output';\nimport { evaluateAppend } from './append';\nimport { evaluateVar, prepareVarAssignment, type VarAssignmentResult } from './var';\nimport { evaluateShow } from './show';\nimport { evaluateExe } from './exe';\nimport { evaluateForDirective } from './for';\nimport { evaluateExport } from './export';\nimport { evaluateGuard } from './guard';\nimport { evaluateNeeds, evaluateWants } from './needs';\nimport { clearDirectiveReplay } from './directive-replay';\nimport { runWithGuardRetry } from '../hooks/guard-retry-runner';\nimport { extractSecurityDescriptor } from '../utils/structured-value';\nimport { updateVarMxFromDescriptor } from '@core/types/variable/VarMxHelpers';\nimport { evaluatePolicy } from './policy';\n\n/**\n * Extract trace information from a directive\n */\nfunction extractTraceInfo(directive: DirectiveNode): {\n  directive: string;\n  varName?: string;\n} {\n  const info: { directive: string; varName?: string } = {\n    directive: `/${directive.kind}`\n  };\n  \n  // Extract variable/exec names based on directive type\n  switch (directive.kind) {\n    case 'path':\n    case 'var':\n      // /path @varName = ... or /var @varName = ...\n      const identifierNodes = directive.values?.identifier;\n      if (identifierNodes && Array.isArray(identifierNodes) && identifierNodes.length > 0) {\n        const identifier = identifierNodes[0];\n        if (identifier?.type === 'Text' && 'content' in identifier) {\n          info.varName = identifier.content;\n        } else if (identifier?.type === 'VariableReference' && 'identifier' in identifier) {\n          info.varName = identifier.identifier;\n        }\n      }\n      break;\n      \n    case 'run':\n      // /run @execName or /run [command]\n      if (directive.subtype === 'runExec') {\n        const execId = directive.values?.identifier?.[0];\n        if (execId?.type === 'Text' && 'content' in execId) {\n          info.varName = `@${execId.content}`;\n        }\n      }\n      break;\n      \n    case 'exec':\n    case 'exe':\n      // /exec @funcName(...) = ... or /exe @funcName(...) = ...\n      const execName = directive.values?.name?.[0];\n      const execNameContent = getTextContent(execName);\n      if (execNameContent) {\n        info.varName = execNameContent;\n      }\n      break;\n      \n    case 'foreach':\n      // foreach @template(@items)\n      const template = directive.values?.template?.[0];\n      const templateContent = getTextContent(template);\n      if (templateContent) {\n        info.varName = templateContent;\n      }\n      break;\n      \n    case 'import':\n      // /import { ... } from \"path\"\n      const importPath = directive.values?.path?.[0];\n      const pathContent = getTextContent(importPath);\n      if (pathContent) {\n        // Show just the filename for cleaner trace\n        info.varName = pathContent.split('/').pop()?.replace(/\\.mld$/, '');\n      }\n      break;\n\n    case 'export':\n      // /export { name, other }\n      const firstExport = directive.values?.exports?.[0];\n      if (firstExport && typeof firstExport.identifier === 'string') {\n        info.varName = firstExport.identifier;\n      }\n      break;\n\n    case 'policy':\n      const policyNameNode = (directive.values as any)?.name?.[0];\n      const policyName = getTextContent(policyNameNode);\n      if (policyName) {\n        info.varName = policyName;\n      }\n      break;\n  }\n  \n  return info;\n}\n\n/**\n * Main directive evaluation router.\n * Routes to specific evaluators based on directive kind.\n */\nexport async function evaluateDirective(\n  directive: DirectiveNode,\n  env: Environment,\n  context?: EvaluationContext\n): Promise<EvalResult> {\n  // Extract trace info and push to stack\n  const traceInfo = extractTraceInfo(directive);\n  env.pushDirective(\n    traceInfo.directive,\n    traceInfo.varName,\n    directive.location\n  );\n\n  const hookManager = env.getHookManager();\n  const operationContext = buildOperationContext(directive, traceInfo);\n\n  try {\n    const executeOnce = async (): Promise<EvalResult> => {\n      return await env.withOpContext(operationContext, async () => {\n        let extractedInputs: readonly unknown[] = [];\n        let precomputedVarAssignment: VarAssignmentResult | undefined;\n\n        if (directive.kind === 'var') {\n          precomputedVarAssignment = await prepareVarAssignment(directive, env);\n          extractedInputs = [precomputedVarAssignment.variable];\n        } else {\n          extractedInputs = await extractDirectiveInputs(directive, env);\n        }\n        const preDecision = await hookManager.runPre(\n          directive,\n          extractedInputs,\n          env,\n          operationContext\n        );\n        const transformedInputs = getGuardTransformedInputs(preDecision, extractedInputs);\n        if (precomputedVarAssignment && transformedInputs && transformedInputs[0]) {\n          const firstTransformed = transformedInputs[0];\n          if (isVariable(firstTransformed)) {\n            precomputedVarAssignment = {\n              ...precomputedVarAssignment,\n              variable: firstTransformed as Variable\n            };\n          }\n        }\n\n        const resolvedInputs = transformedInputs ?? extractedInputs;\n        await handleGuardDecision(preDecision, directive, env, operationContext);\n\n        const mergedContext = mergeEvaluationContext(\n          context,\n          resolvedInputs,\n          operationContext,\n          precomputedVarAssignment\n        );\n\n        let result = await dispatchDirective(directive, env, mergedContext);\n        result = await hookManager.runPost(directive, result, resolvedInputs, env, operationContext);\n\n        if (directive.kind === 'var' && precomputedVarAssignment && (result as any).__guardTransformed) {\n          const targetVar = env.getVariable(precomputedVarAssignment.identifier) ?? {\n            ...precomputedVarAssignment.variable\n          };\n\n          if (isVariable(result.value)) {\n            const replacement = result.value as Variable;\n            targetVar.value = (replacement as any).value ?? replacement;\n            targetVar.mx = {\n              ...(targetVar.mx ?? {}),\n              ...(replacement.mx ?? {})\n            };\n          } else {\n            targetVar.value = result.value;\n            const descriptor = extractSecurityDescriptor(result.value, {\n              recursive: true,\n              mergeArrayElements: true\n            });\n            if (descriptor) {\n              const mx = (targetVar.mx ?? (targetVar.mx = {} as any)) as Record<string, unknown>;\n              updateVarMxFromDescriptor(mx, descriptor);\n              if ('mxCache' in mx) {\n                delete (mx as any).mxCache;\n              }\n            }\n          }\n        }\n        return result;\n      });\n    };\n\n    const sourceRetryable =\n      (operationContext.metadata &&\n        typeof (operationContext.metadata as any).sourceRetryable === 'boolean' &&\n        (operationContext.metadata as any).sourceRetryable === true) ||\n      false;\n\n    return await runWithGuardRetry({\n      env,\n      operationContext,\n      sourceRetryable,\n      execute: executeOnce\n    });\n  } catch (error) {\n    // Enhance errors with directive trace\n    const trace = env.getDirectiveTrace();\n    \n    // Check if this is an import parse error\n    if (error && typeof error === 'object' && 'importParseError' in error) {\n      const parseError = (error as any).importParseError;\n      // Mark the current import directive as failed\n      env.markLastDirectiveFailed(\n        `${parseError.file}.mld failed to parse at line ${parseError.line}: ${parseError.message}`\n      );\n    }\n    \n    if (trace.length > 0) {\n      if (error && typeof error === 'object') {\n        // For MlldError objects with details property\n        if ('details' in error && typeof error.details === 'object') {\n          if (!error.details.directiveTrace) {\n            error.details = {\n              ...error.details,\n              directiveTrace: trace\n            };\n          }\n        } \n        // For regular Error objects, add a custom property\n        else if (error instanceof Error) {\n          (error as any).mlldTrace = trace;\n        }\n      }\n    }\n    throw error;\n  } finally {\n    // Always pop the directive from the trace\n    env.popDirective();\n    clearDirectiveReplay(directive);\n  }\n}\n\nfunction mergeEvaluationContext(\n  baseContext: EvaluationContext | undefined,\n  extractedInputs: readonly unknown[],\n  operationContext: OperationContext,\n  precomputedVarAssignment?: VarAssignmentResult\n): EvaluationContext {\n  const extra: EvaluationContext = {\n    extractedInputs,\n    operationContext,\n    precomputedVarAssignment\n  };\n  return baseContext ? { ...baseContext, ...extra } : extra;\n}\n\nfunction buildOperationContext(\n  directive: DirectiveNode,\n  traceInfo: { directive: string; varName?: string }\n): OperationContext {\n  const labels = (directive.meta?.securityLabels || directive.values?.securityLabels) as string[] | undefined;\n  const baseMetadata: Record<string, unknown> = {\n    trace: traceInfo.directive\n  };\n  const streamingEnabled = readStreamFlag(directive);\n  const context: OperationContext = {\n    type: directive.kind,\n    subtype: directive.subtype,\n    labels,\n    name: traceInfo.varName,\n    location: directive.location ?? null,\n    metadata: streamingEnabled ? { ...baseMetadata, streaming: true } : baseMetadata\n  };\n\n  switch (directive.kind) {\n    case 'run':\n      applyRunMetadata(context, directive);\n      break;\n    case 'import':\n      applyImportMetadata(context, directive);\n      break;\n    case 'output':\n    case 'append':\n      applyOutputMetadata(context, directive);\n      break;\n    case 'var':\n      applyVarMetadata(context, directive);\n      break;\n    case 'show':\n    case 'stream':\n      applyShowMetadata(context, directive);\n      break;\n  }\n\n  return context;\n}\n\nasync function dispatchDirective(\n  directive: DirectiveNode,\n  env: Environment,\n  evaluationContext?: EvaluationContext\n): Promise<EvalResult> {\n  switch (directive.kind) {\n    case 'path':\n      return await evaluatePath(directive, env);\n\n    case 'run':\n      return await evaluateRun(directive, env, [], evaluationContext);\n\n    case 'import':\n      return await evaluateImport(directive, env);\n\n    case 'when':\n      return await evaluateWhen(directive as any, env);\n\n    case 'output':\n      return await evaluateOutput(directive, env, evaluationContext);\n\n    case 'append':\n      return await evaluateAppend(directive, env, evaluationContext);\n\n    case 'var':\n      return await evaluateVar(directive, env, evaluationContext);\n\n    case 'show':\n      return await evaluateShow(directive, env, evaluationContext);\n    case 'stream':\n      return await evaluateShow(directive, env, evaluationContext);\n\n    case 'exe':\n      return await evaluateExe(directive, env);\n\n    case 'for':\n      return await evaluateForDirective(directive as any, env);\n\n    case 'export':\n      return await evaluateExport(directive as any, env);\n\n    case 'guard':\n      return await evaluateGuard(directive, env);\n\n    case 'needs':\n      return await evaluateNeeds(directive, env);\n\n    case 'wants':\n      return await evaluateWants(directive, env);\n\n    case 'policy':\n      return await evaluatePolicy(directive as PolicyDirectiveNode, env);\n\n    default:\n      throw new Error(`Unknown directive kind: ${directive.kind}`);\n  }\n}\n\nfunction applyRunMetadata(context: OperationContext, directive: DirectiveNode): void {\n  const metadata: Record<string, unknown> = { ...(context.metadata ?? {}) };\n  metadata.runSubtype = directive.subtype;\n  const language = directive.meta?.language;\n  if (typeof language === 'string' && language.length > 0) {\n    metadata.language = language;\n  }\n\n  if (directive.subtype === 'runCommand') {\n    const nodes = directive.values?.identifier || directive.values?.command;\n    const preview = summarizeNodes(nodes);\n    if (preview) {\n      context.command = preview;\n      metadata.commandPreview = preview;\n    }\n  } else if (directive.subtype === 'runExec') {\n    const execNode = directive.values?.identifier?.[0];\n    const execName = execNode ? getTextContent(execNode) : undefined;\n    if (execName) {\n      context.command = `@${execName}`;\n      metadata.execName = execName;\n    }\n  }\n\n  context.metadata = metadata;\n}\n\nfunction applyImportMetadata(context: OperationContext, directive: DirectiveNode): void {\n  const metadata: Record<string, unknown> = { ...(context.metadata ?? {}) };\n  const pathNode = directive.values?.path?.[0];\n  const path = pathNode ? getTextContent(pathNode) : undefined;\n  if (path) {\n    context.target = path;\n  }\n  context.metadata = metadata;\n}\n\nfunction applyOutputMetadata(context: OperationContext, directive: DirectiveNode): void {\n  const metadata: Record<string, unknown> = { ...(context.metadata ?? {}) };\n  const pathNode =\n    directive.values?.path?.[0] ||\n    directive.values?.target?.path?.[0] ||\n    (Array.isArray(directive.values?.target)\n      ? directive.values.target[0]?.path?.[0]\n      : undefined);\n  const path = pathNode ? getTextContent(pathNode) : undefined;\n  if (path) {\n    context.target = path;\n  }\n  const targetType = directive.meta?.targetType;\n  if (targetType) {\n    metadata.outputTargetType = targetType;\n  }\n  context.metadata = metadata;\n}\n\nfunction applyVarMetadata(context: OperationContext, directive: DirectiveNode): void {\n  const metadata: Record<string, unknown> = { ...(context.metadata ?? {}) };\n  const identifierNodes = directive.values?.identifier;\n  const varName = identifierNodes && identifierNodes[0] ? getTextContent(identifierNodes[0]) : undefined;\n  if (varName) {\n    context.target = varName;\n  }\n  metadata.sourceRetryable = true;\n  context.metadata = metadata;\n}\n\nfunction applyShowMetadata(context: OperationContext, directive: DirectiveNode): void {\n  const metadata: Record<string, unknown> = { ...(context.metadata ?? {}) };\n  metadata.showSubtype = directive.subtype;\n  metadata.sourceRetryable = true;\n  context.metadata = metadata;\n}\n\nfunction readStreamFlag(directive: DirectiveNode): boolean {\n  const candidates = [\n    (directive.values as any)?.withClause?.stream,\n    (directive.values as any)?.invocation?.withClause?.stream,\n    (directive.values as any)?.execInvocation?.withClause?.stream,\n    directive.meta?.withClause?.stream\n  ];\n\n  return candidates.some(value => value === true || value === 'true');\n}\n\nfunction summarizeNodes(nodes: unknown): string | undefined {\n  if (!nodes) {\n    return undefined;\n  }\n  const array = Array.isArray(nodes) ? nodes : [nodes];\n  const parts = array\n    .map(node => (typeof node === 'string' ? node : getTextContent(node as any) ?? ''))\n    .join('');\n  const preview = parts.trim();\n  if (!preview) {\n    return undefined;\n  }\n  return preview.length > 120 ? `${preview.slice(0, 117)}...` : preview;\n}\n","import type { Environment } from '../env/Environment';\nimport type { MlldNode } from '@core/types';\nimport { isTruthy } from './expression';\n\nexport async function evaluateConditionalInclusion(\n  conditionNode: MlldNode,\n  env: Environment,\n  options?: { valueNode?: unknown }\n): Promise<{ shouldInclude: boolean; value: unknown }> {\n  const { evaluate } = await import('../core/interpreter');\n  const result = await evaluate(conditionNode, env, { isExpression: true, isCondition: true });\n  const shouldInclude = isTruthy(result.value);\n\n  if (!shouldInclude) {\n    return { shouldInclude, value: result.value };\n  }\n\n  if (options?.valueNode) {\n    const { evaluateDataValue } = await import('./data-value-evaluator');\n    const value = await evaluateDataValue(options.valueNode as any, env);\n    return { shouldInclude, value };\n  }\n\n  return { shouldInclude, value: result.value };\n}\n","import type {\n  CondensedPipe,\n  FieldAccessNode,\n  FileReferenceNode,\n  MlldNode,\n  ExecInvocation\n} from '@core/types';\nimport type { LoadContentResult } from '@core/types/load-content';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { asText, assertStructuredValue, isStructuredValue } from '@interpreter/utils/structured-value';\nimport { varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\nimport type { Environment } from '../env/Environment';\nimport type { VarAssignmentResult } from '../eval/var';\nimport type { OperationContext } from '../env/ContextManager';\nimport { EscapingStrategyFactory, InterpolationContext } from '../core/interpolation-context';\nimport { interpreterLogger as logger } from '@core/utils/logger';\nimport { evaluateDataValue } from '../eval/data-value-evaluator';\nimport { evaluateConditionalInclusion } from '../eval/conditional-inclusion';\nimport { classifyShellValue } from '../utils/shell-value';\nimport * as shellQuote from 'shell-quote';\n\n/**\n * ASSERTION HELPER FOR PHASE 2.3 MIGRATION\n *\n * Enable runtime assertions during migration to verify array behavior changes.\n * Set MLLD_ASSERT_ARRAY_BEHAVIOR=true to enable assertion mode.\n *\n * These assertions help catch unexpected behavior changes when migrating from\n * specific array type checks to generic StructuredValue array handling.\n */\nconst ASSERT_MODE = process.env.MLLD_ASSERT_ARRAY_BEHAVIOR === 'true';\n\nfunction assertArrayBehavior(condition: boolean, message: string, context?: Record<string, unknown>): void {\n  if (ASSERT_MODE && !condition) {\n    const contextStr = context ? `\\nContext: ${JSON.stringify(context, null, 2)}` : '';\n    throw new Error(`[ARRAY MIGRATION ASSERTION] ${message}${contextStr}`);\n  }\n}\n\nexport interface InterpolationNode {\n  type: string;\n  content?: string;\n  name?: string;\n  identifier?: string;\n  fields?: FieldAccessNode[];\n  value?: string;\n  commandRef?: any;\n  withClause?: any;\n  pipes?: CondensedPipe[];\n}\n\nexport interface InterpolateOptions {\n  collectSecurityDescriptor?: (descriptor: SecurityDescriptor) => void;\n}\n\nexport type InterpolateFunction = (\n  nodes: any,\n  env: Environment,\n  context?: InterpolationContext,\n  options?: InterpolateOptions\n) => Promise<string>;\n\nexport interface EvalResultLike {\n  value: unknown;\n  env: Environment;\n  stdout?: string;\n  stderr?: string;\n  exitCode?: number;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface EvaluationContextLike {\n  isCondition?: boolean;\n  isExpression?: boolean;\n  extractedInputs?: readonly unknown[];\n  operationContext?: OperationContext;\n  precomputedVarAssignment?: VarAssignmentResult;\n}\n\ntype EvaluateFn = (\n  node: MlldNode | MlldNode[],\n  env: Environment,\n  context?: EvaluationContextLike\n) => Promise<EvalResultLike>;\n\nexport interface InterpolationDependencies {\n  evaluate: EvaluateFn;\n}\n\nexport type Interpolator = (\n  nodes: InterpolationNode[],\n  env: Environment,\n  context?: InterpolationContext,\n  options?: InterpolateOptions\n) => Promise<string>;\n\nexport function createInterpolator(getDeps: () => InterpolationDependencies): Interpolator {\n  const interpolateImpl: Interpolator = async function interpolate(\n    nodes,\n    env,\n    context: InterpolationContext = InterpolationContext.Default,\n    options?: InterpolateOptions\n  ): Promise<string> {\n    logger.info('[INTERPOLATE] interpolate() called');\n    \n    // Handle non-array inputs\n    if (!Array.isArray(nodes)) {\n      if (typeof nodes === 'string') {\n        return nodes;\n      }\n      if (nodes && typeof nodes === 'object' && 'content' in nodes) {\n        return nodes.content || '';\n      }\n      return String(nodes || '');\n    }\n    \n    const parts: string[] = [];\n    let withinDoubleQuotes = false;\n    let withinSingleQuotes = false;\n\n    const updateQuoteState = (fragment: string): void => {\n      if (!fragment) return;\n      let backslashCount = 0;\n      for (let i = 0; i < fragment.length; i++) {\n        const char = fragment[i];\n        if (char === '\\\\') {\n          backslashCount++;\n          continue;\n        }\n        if (char === '\"' || char === '\\'') {\n          const isEscaped = backslashCount % 2 === 1;\n          if (char === '\"' && !withinSingleQuotes && !isEscaped) {\n            withinDoubleQuotes = !withinDoubleQuotes;\n          } else if (char === '\\'' && !withinDoubleQuotes && !isEscaped) {\n            withinSingleQuotes = !withinSingleQuotes;\n          }\n        }\n        backslashCount = 0;\n      }\n    };\n\n    const pushPart = (fragment: string): void => {\n      const value = fragment ?? '';\n      parts.push(value);\n      if (context === InterpolationContext.ShellCommand) {\n        updateQuoteState(value);\n      }\n    };\n    const collectDescriptor = (descriptor?: SecurityDescriptor): void => {\n      if (!descriptor) {\n        return;\n      }\n      options?.collectSecurityDescriptor?.(descriptor);\n    };\n\n    const { evaluate } = getDeps();\n    \n    for (const node of nodes) {\n      if (node.type === 'Text') {\n        // Handle Text nodes - directly use string content\n        pushPart(node.content || '');\n      } else if (node.type === 'PathSeparator') {\n        pushPart(node.value || '/');\n      } else if (node.type === 'ConditionalTemplateSnippet' || node.type === 'ConditionalStringFragment') {\n        const conditionNode = (node as any).condition;\n        const contentNodes = (node as any).content;\n        const { shouldInclude } = await evaluateConditionalInclusion(conditionNode, env);\n        if (!shouldInclude) {\n          continue;\n        }\n        const snippet = await interpolateImpl(Array.isArray(contentNodes) ? contentNodes : [], env, context, options);\n        pushPart(snippet);\n      } else if (node.type === 'ExecInvocation') {\n        // Handle function calls in templates\n        const { evaluateExecInvocation } = await import('../eval/exec-invocation');\n        const result = await evaluateExecInvocation(node as any, env);\n        collectDescriptor(extractInterpolationDescriptor(result.value));\n        pushPart(asText(result.value));\n      } else if (node.type === 'InterpolationVar') {\n        // Handle {{var}} style interpolation (from triple colon templates)\n        const varName = node.identifier || node.name;\n        if (!varName) continue;\n        \n        let variable = env.getVariable(varName);\n        \n        // Check if this is a resolver variable that needs async resolution\n        if (!variable && env.hasVariable(varName)) {\n          // Try to get it as a resolver variable\n          const resolverVar = await env.getResolverVariable(varName);\n          if (resolverVar) {\n            variable = resolverVar;\n          }\n        }\n        \n        if (!variable) {\n          if (process.env.MLLD_DEBUG === 'true') {\n            logger.debug('Variable not found during {{var}} interpolation:', { varName });\n          }\n          pushPart(`{{${varName}}}`); // Keep unresolved with {{}} syntax\n          continue;\n        }\n        collectDescriptor(variable.mx ? varMxToSecurityDescriptor(variable.mx) : undefined);\n        \n        /**\n         * Extract Variable value for string interpolation\n         * WHY: String interpolation needs raw values because template engines\n         *      work with primitive types, not Variable wrapper objects\n         */\n        const { resolveVariable, ResolutionContext } = await import('../utils/variable-resolution');\n        const value = await resolveVariable(variable, env, ResolutionContext.StringInterpolation);\n        collectDescriptor(extractInterpolationDescriptor(value));\n        \n        // Convert final value to string\n        let stringValue: string;\n        if (value === null) {\n          stringValue = 'null';\n        } else if (value === undefined) {\n          stringValue = '';\n        } else if (isStructuredValue(value)) {\n          stringValue = asText(value);\n          collectDescriptor(extractInterpolationDescriptor(value));\n          \n          if (value.type === 'Path') {\n            const classification = classifyShellValue(value.value);\n            if (classification.type === 'path') {\n              stringValue = classification.value;\n            }\n          } else if (value.type === 'CommandResult') {\n            const classification = classifyShellValue(value.text);\n            if (classification.type === 'path') {\n              stringValue = classification.value;\n            }\n          } else if (value.type === 'PipelineInput') {\n            assertStructuredValue(value, 'interpolate:pipeline-input');\n            stringValue = asText(value);\n          } else if (isStructuredValue(value) && value.type === 'array') {\n            // StructuredValue arrays already have proper .text\n            stringValue = value.text;\n          }\n        } else if (typeof value === 'object') {\n          stringValue = JSON.stringify(value);\n          if (process.env.MLLD_DEBUG === 'true') {\n          }\n        } else {\n          stringValue = String(value);\n        }\n        \n        pushPart(stringValue);\n        logger.debug('[INTERPOLATE] Pushed to parts:', { stringValue, partsLength: parts.length });\n      } else if (node.type === 'TemplateVariable') {\n        // Template variables have .internal.templateAst for value\n        const varName = node.identifier || node.name;\n        if (!varName) continue;\n        const variable = env.getVariable(varName);\n        if (!variable) {\n          pushPart(`@${varName}`);\n          continue;\n        }\n        \n        collectDescriptor(variable.mx ? varMxToSecurityDescriptor(variable.mx) : undefined);\n        \n        // Template variable content needs template escaping context\n        if (variable.internal?.templateAst) {\n          const templateContent = await interpolateImpl(variable.internal.templateAst, env, InterpolationContext.Template, options);\n          pushPart(templateContent);\n        } else {\n          const strategy = EscapingStrategyFactory.getStrategy(context);\n          const value = asText(variable.value);\n          pushPart(strategy.escape(value));\n        }\n      } else if (node.type === 'VariableReference' || node.type === 'VariableReferenceWithTail' || node.type === 'TemplateVariable') {\n        // Complex variable references (with field access, pipes, etc.)\n        const varName = (node as any).identifier || (node as any).name;\n        let variable = env.getVariable(varName);\n        \n        // Allow resolver variables (async evaluation)\n        if (!variable && env.hasVariable(varName)) {\n          const resolverVar = await env.getResolverVariable(varName);\n          if (resolverVar) {\n            variable = resolverVar;\n          }\n        }\n        \n        if (!variable) {\n          if (process.env.MLLD_DEBUG === 'true') {\n            logger.debug('Variable not found during interpolation:', { varName, valueType: node.valueType });\n          }\n          // WHY: Preserve original syntax when variable is undefined for better error messages\n          if (node.valueType === 'varInterpolation') {\n            pushPart(`{{${varName}}}`);  // {{var}} syntax\n          } else {\n            pushPart(`@${varName}`);      // @var syntax\n          }\n          continue;\n        }\n\n        collectDescriptor(variable.mx ? varMxToSecurityDescriptor(variable.mx) : undefined);\n\n        // Extract value based on variable type using new type guards\n        let value: unknown = '';\n        \n        // Import isExecutableVariable dynamically\n        const { isExecutableVariable } = await import('@core/types/variable');\n        \n        // Special handling for executable variables\n        if (isExecutableVariable(variable)) {\n          const { evaluateExecInvocation } = await import('../eval/exec-invocation');\n          const commandRef = (node as any).commandRef || {\n            identifier: variable.name,\n            args: []\n          };\n          const execInvocation: ExecInvocation = {\n            type: 'ExecInvocation',\n            commandRef: {\n              identifier: commandRef.identifier || variable.name || (node as any).name || (node as any).identifier,\n              args: commandRef.args || []\n            },\n            location: commandRef.location || (node as any).location\n          };\n          const result = await evaluateExecInvocation(execInvocation, env);\n          collectDescriptor(extractInterpolationDescriptor(result.value));\n          const execOutput = asText(result.value);\n          const strategy = EscapingStrategyFactory.getStrategy(context);\n          pushPart(strategy.escape(execOutput));\n          continue;\n        }\n        \n        // Handle TemplateVariable references (e.g., ::{{var}}::)\n        if ((node as any).type === 'TemplateVariable') {\n          if ((node as any).content) {\n            value = await interpolateImpl((node as any).content as any[], env, InterpolationContext.Template, options);\n          } else if (variable.internal?.templateAst) {\n            value = await interpolateImpl(variable.internal.templateAst, env, InterpolationContext.Template, options);\n          }\n          pushPart(String(value ?? ''));\n          continue;\n        }\n        \n        const { resolveVariable, ResolutionContext } = await import('../utils/variable-resolution');\n        const fields = (node as any).fields as any[] | undefined;\n        const wantsVarMx =\n          Array.isArray(fields) &&\n          fields.length > 0 &&\n          fields[0]?.type === 'field' &&\n          String(fields[0]?.value ?? '') === 'mx';\n        const resolutionContext = wantsVarMx ? ResolutionContext.FieldAccess : ResolutionContext.StringInterpolation;\n        \n        value = await resolveVariable(variable, env, resolutionContext);\n        collectDescriptor(extractInterpolationDescriptor(value));\n        \n        // Special handling for lazy reserved variables like DEBUG\n        if (value === null && variable.internal?.isReserved && variable.internal?.isLazy) {\n          // Need to resolve this as a resolver variable\n          const resolverVar = await env.getResolverVariable(varName);\n          if (resolverVar && resolverVar.value !== null) {\n            value = resolverVar.value;\n          }\n        }\n        \n        // Handle field access if present\n        let fieldsToProcess = node.fields || [];\n        if (fieldsToProcess.length > 0 && (typeof value === 'object' || typeof value === 'string') && value !== null) {\n          const { accessField } = await import('../utils/field-access');\n          for (const field of fieldsToProcess) {\n            // Handle variableIndex type - need to resolve the variable first\n            if (field.type === 'variableIndex') {\n              const { evaluateDataValue } = await import('../eval/data-value-evaluator');\n              const indexNode =\n                typeof field.value === 'object'\n                  ? (field.value as any)\n                  : {\n                      type: 'VariableReference',\n                      valueType: 'varIdentifier',\n                      identifier: String(field.value)\n                    };\n              const indexValue = await evaluateDataValue(indexNode as any, env);\n              // Create a new field with the resolved value\n              const resolvedField = { type: 'bracketAccess' as const, value: indexValue };\n              const fieldResult = await accessField(value, resolvedField, { \n                preserveContext: true,\n                env \n              });\n              value = (fieldResult as any).value;\n            } else {\n              const fieldResult = await accessField(value, field, { \n                preserveContext: true,\n                env \n              });\n              value = (fieldResult as any).value;\n            }\n            \n            // Handle null nodes from the grammar\n            if (value && typeof value === 'object' && 'type' in value) {\n              const nodeValue = value as Record<string, unknown>;\n              if (nodeValue.type === 'Null') {\n                value = null;\n              } else if (nodeValue.type === 'runExec' || nodeValue.type === 'ExecInvocation' || \n                         nodeValue.type === 'command' || nodeValue.type === 'code' ||\n                         nodeValue.type === 'VariableReference' || nodeValue.type === 'path') {\n                // This is an unevaluated AST node from a complex object\n                // We need to evaluate it\n                value = await evaluateDataValue(value, env);\n              }\n            }\n            \n            if (value === undefined) break;\n          }\n        }\n        \n        // Handle pipes if present\n        if (node.pipes && node.pipes.length > 0) {\n          const { processPipeline } = await import('../eval/pipeline/unified-processor');\n          value = await processPipeline({\n            value,\n            env,\n            node,\n            identifier: node.identifier,\n            descriptorHint: variable?.mx ? varMxToSecurityDescriptor(variable.mx) : undefined\n          });\n          if (typeof value === 'string') {\n            const strategy = EscapingStrategyFactory.getStrategy(context);\n            pushPart(strategy.escape(value));\n            continue;\n          }\n        }\n        \n        const { resolveValue, ResolutionContext: ResContext } = await import('../utils/variable-resolution');\n        value = await resolveValue(value, env, ResContext.StringInterpolation);\n        \n        if (context === InterpolationContext.ShellCommand) {\n          const classification = classifyShellValue(value);\n          const strategy = EscapingStrategyFactory.getStrategy(context);\n\n          const escapeForSingleQuotes = (text: string): string => {\n            if (text === '\\'') {\n              return '\\'';\n            }\n            if (!text.includes('\\'')) {\n              return text;\n            }\n            const segments = text.split('\\'');\n            return segments\n              .map((segment, index) => {\n                if (index === segments.length - 1) {\n                  return segment;\n                }\n                return `${segment}'\\\\''`;\n              })\n              .join('');\n          };\n          const escapeForDoubleQuotes = (text: string): string => strategy.escape(text);\n\n          if (classification.kind === 'simple') {\n            if (withinSingleQuotes) {\n              pushPart(escapeForSingleQuotes(classification.text));\n            } else {\n              pushPart(escapeForDoubleQuotes(classification.text));\n            }\n          } else if (classification.kind === 'array-simple') {\n            if (withinSingleQuotes) {\n              const escapedElements = classification.elements.map(elem => escapeForSingleQuotes(elem));\n              pushPart(escapedElements.join(' '));\n            } else {\n              const escapedElements = classification.elements.map(elem => escapeForDoubleQuotes(elem));\n              pushPart(escapedElements.join(' '));\n            }\n          } else {\n            if (withinDoubleQuotes) {\n              pushPart(escapeForDoubleQuotes(classification.text));\n            } else if (withinSingleQuotes) {\n              pushPart(escapeForSingleQuotes(classification.text));\n            } else {\n              pushPart(shellQuote.quote([classification.text]));\n            }\n          }\n          continue;\n        }\n        \n        // Convert to string\n        let stringValue: string;\n        \n        if (value === null) {\n          stringValue = 'null';\n        } else if (value === undefined) {\n          stringValue = '';\n        } else if (isStructuredValue(value)) {\n          stringValue = asText(value);\n        } else if (typeof value === 'object' && 'wrapperType' in value && 'content' in value && Array.isArray((value as any).content)) {\n          // Handle wrapped strings (quotes, backticks, brackets)\n          stringValue = await interpolateImpl((value as any).content, env, context, options);\n        } else if (typeof value === 'object' && 'type' in (value as Record<string, unknown>)) {\n          const nodeValue = value as Record<string, unknown>;\n          \n          if (nodeValue.type === 'array' && 'items' in nodeValue) {\n            const evaluatedArray = await evaluateDataValue(value, env);\n            if (Array.isArray(evaluatedArray)) {\n              const { JSONFormatter } = await import('../core/json-formatter');\n              stringValue = JSONFormatter.stringify(evaluatedArray);\n            } else {\n              stringValue = String(evaluatedArray);\n            }\n          } else if (nodeValue.type === 'Null') {\n            stringValue = 'null';\n          } else {\n            const { isPipelineInput } = await import('@core/types/variable/TypeGuards');\n            if (isPipelineInput(value)) {\n              stringValue = asText(value);\n            } else {\n              stringValue = JSON.stringify(value);\n            }\n          }\n        } else if (Array.isArray(value)) {\n          if (isStructuredValue(value) && value.type === 'array') {\n            // MIGRATION: This branch handles StructuredValue arrays (glob patterns)\n            // Expected behavior: Join array items with \\n\\n separator (already in .text)\n            stringValue = value.text;\n            assertArrayBehavior(\n              typeof stringValue === 'string',\n              'StructuredValue array should have .text property',\n              { arrayLength: Array.isArray(value.data) ? value.data.length : 0, resultType: typeof stringValue }\n            );\n          } else {\n            // MIGRATION: Generic array handling\n            const { JSONFormatter } = await import('../core/json-formatter');\n            const printableArray = value.map(item => {\n              if (isStructuredValue(item)) {\n                if (item.type === 'object' || item.type === 'array' || item.type === 'json') {\n                  return item.data;\n                }\n                return asText(item);\n              }\n              return item;\n            });\n            stringValue = JSONFormatter.stringify(printableArray);\n          }\n        } else if (typeof value === 'object') {\n          const { isLoadContentResult } = await import('@core/types/load-content');\n          if (isLoadContentResult(value)) {\n            stringValue = asText(value);\n          } else if (isStructuredValue(value) && value.type === 'array') {\n            // StructuredValue arrays already have concatenated text\n            stringValue = value.text;\n          } else if (variable && variable.internal?.isNamespace && node.fields?.length === 0) {\n            const { JSONFormatter } = await import('../core/json-formatter');\n            stringValue = JSONFormatter.stringifyNamespace(value);\n          } else if ((value as any).__executable) {\n            const params = (value as any).paramNames || [];\n            stringValue = `<function(${params.join(', ')})>`;\n          } else if ((value as any).type === 'path' && (value as any).values) {\n            const { interpolate: pathInterpolate } = await import('../core/interpreter');\n            stringValue = await pathInterpolate((value as any).values.segments || [], env, InterpolationContext.FilePath, options);\n          } else {\n            const { JSONFormatter } = await import('../core/json-formatter');\n            stringValue = JSONFormatter.stringify(value);\n          }\n        } else {\n          stringValue = String(value);\n        }\n        \n        // Apply context-appropriate escaping\n        const strategy = EscapingStrategyFactory.getStrategy(context);\n        const escapedValue = strategy.escape(stringValue);\n        pushPart(escapedValue);\n        \n        if (node.boundary) {\n          if (node.boundary.type === 'literal') {\n            pushPart(node.boundary.value);\n          }\n        }\n      } else if (node.type === 'ExecInvocation') {\n        // Handle exec invocation nodes in interpolation\n        const { evaluateExecInvocation } = await import('../eval/exec-invocation');\n        const result = await evaluateExecInvocation(node as ExecInvocation, env);\n        collectDescriptor(extractInterpolationDescriptor(result.value));\n        const stringValue = asText(result.value);\n        \n        // Apply context-appropriate escaping\n        const strategy = EscapingStrategyFactory.getStrategy(context);\n        pushPart(strategy.escape(stringValue));\n      } else if (node.type === 'FileReference') {\n        // Handle file reference interpolation\n        const result = await interpolateFileReference(node as any, env, context, interpolateImpl);\n        pushPart(result);\n      } else if (node.type === 'TemplateForBlock') {\n        // Inline template for-loop expansion\n        // Evaluate the source collection in expression context\n        const sourceEval = await evaluate(node.source, env, { isExpression: true });\n        const { toIterable } = await import('../eval/for-utils');\n        const iterable = toIterable(sourceEval.value);\n        if (!iterable) {\n          // Non-iterable: skip silently in template context\n          continue;\n        }\n        // Variable importer for proper Variable wrapping\n        const { VariableImporter } = await import('../eval/import/VariableImporter');\n        const importer = new VariableImporter();\n        for (const [key, value] of iterable as Iterable<[string | null, unknown]>) {\n          const childEnv = env.createChildEnvironment();\n          const varName = (node as any).variable?.identifier || (node as any).variable?.name || 'item';\n          const iterationVar = importer.createVariableFromValue(varName, value, 'template-for', undefined, { env });\n          childEnv.setVariable(varName, iterationVar);\n          if (key !== null && key !== undefined) {\n            const keyVar = importer.createVariableFromValue(`${varName}_key`, key, 'template-for', undefined, { env });\n            childEnv.setVariable(`${varName}_key`, keyVar);\n          }\n          const bodyStr = await interpolateImpl((node as any).body as any[], childEnv, InterpolationContext.Template, options);\n          pushPart(bodyStr);\n        }\n      } else if (node.type === 'TemplateInlineShow') {\n        // Build a synthetic show directive and evaluate in capture mode\n        const directive: any = {\n          type: 'Directive',\n          kind: 'show',\n          subtype: undefined,\n          values: {},\n          raw: {},\n          meta: { applyTailPipeline: !!(node as any).tail },\n          location: (node as any).location\n        };\n        const n: any = node as any;\n        switch (n.showKind) {\n          case 'command':\n            directive.subtype = 'showCommand';\n            directive.values.command = n.content?.values?.command || n.content?.values || n.content;\n            directive.meta = { ...(directive.meta || {}), ...(n.content?.meta || {}) };\n            if (n.tail) directive.values.withClause = n.tail;\n            break;\n          case 'code':\n            directive.subtype = 'showCode';\n            directive.values.lang = n.lang || [];\n            directive.values.code = n.code || [];\n            directive.meta = { ...(directive.meta || {}), ...(n.meta || {}) };\n            if (n.tail) directive.values.withClause = n.tail;\n            break;\n          case 'template':\n            directive.subtype = 'showTemplate';\n            directive.values.content = n.template?.values?.content ? [{ content: n.template.values.content }] : (n.template?.values ? [n.template.values] : []);\n            directive.meta = { ...(directive.meta || {}), ...(n.template?.meta || {}), isTemplateContent: true };\n            if (n.tail) directive.values.withClause = n.tail;\n            break;\n          case 'load':\n            directive.subtype = 'showLoadContent';\n            directive.values.loadContent = n.loadContent;\n            if (n.tail) directive.values.withClause = n.tail;\n            break;\n          case 'reference':\n            // Distinguish variable vs exec invocation by node type\n            if (n.reference?.type === 'VariableReference' || n.reference?.type === 'VariableReferenceWithTail' || n.reference?.type === 'TemplateVariable') {\n              directive.subtype = 'showVariable';\n              directive.values.variable = n.reference;\n            } else {\n              directive.subtype = 'showExecInvocation';\n              directive.values.execInvocation = n.reference;\n            }\n            break;\n          default:\n            break;\n        }\n        const { evaluateShow } = await import('../eval/show');\n        const res = await evaluateShow(directive, env, { isExpression: true });\n        pushPart(asText(res.value ?? ''));\n      } else if (node.type === 'Literal') {\n        // Handle literal nodes from expressions\n        const { LiteralNode } = await import('@core/types');\n        const literalNode = node as LiteralNode;\n        const value = literalNode.value;\n        let stringValue: string;\n        if (value === null) {\n          stringValue = 'null';\n        } else if (value === undefined) {\n          stringValue = '';\n        } else {\n          stringValue = String(value);\n        }\n        const strategy = EscapingStrategyFactory.getStrategy(context);\n        pushPart(strategy.escape(stringValue));\n      }\n    }\n    \n    const result = parts.join('');\n    \n    return result;\n  };\n  \n  return interpolateImpl;\n}\n\nexport function extractInterpolationDescriptor(value: unknown): SecurityDescriptor | undefined {\n  if (!value) {\n    return undefined;\n  }\n  if (isStructuredValue(value)) {\n    return varMxToSecurityDescriptor(value.mx as any);\n  }\n  if (typeof value === 'object') {\n    const mx = (value as { mx?: Record<string, unknown> }).mx;\n    return mx ? varMxToSecurityDescriptor(mx as any) : undefined;\n  }\n  return undefined;\n}\n\n/**\n * Interpolate file reference nodes (<file.md>) with optional field access and pipes\n */\nexport async function interpolateFileReference(\n  node: FileReferenceNode,\n  env: Environment,\n  context: InterpolationContext,\n  interpolateFn: InterpolateFunction\n): Promise<string> {\n  const { FileReferenceNode } = await import('@core/types');\n  \n  // Special handling for <> placeholder in 'as' contexts\n  if (node.meta?.isPlaceholder) {\n    // Get current file from iteration context\n    const currentFile = env.getCurrentIterationFile?.();\n    if (!currentFile) {\n      throw new Error('<> can only be used in \"as\" template contexts');\n    }\n    return processFileFields(currentFile, node.fields, node.pipes, env);\n  }\n  \n  // Process the path (may contain variables)\n  let resolvedPath: string;\n  if (typeof node.source === 'string') {\n    resolvedPath = node.source;\n  } else if (node.source.raw) {\n    resolvedPath = node.source.raw;\n  } else if (node.source.segments) {\n    resolvedPath = await interpolateFn(node.source.segments, env);\n  } else {\n    resolvedPath = await interpolateFn([node.source], env);\n  }\n  \n  // Check if file interpolation is enabled\n  if (!env.isFileInterpolationEnabled()) {\n    throw new Error('File interpolation disabled by security policy');\n  }\n  \n  // Check circular reference\n  if (env.isInInterpolationStack(resolvedPath)) {\n    console.error(`Warning: Circular reference detected - '${resolvedPath}' references itself, skipping`);\n    return '';  // Return empty string and continue\n  }\n  \n  // Add to stack\n  env.pushInterpolationStack(resolvedPath);\n  \n  try {\n    // Use existing content loader\n    const { processContentLoader } = await import('../eval/content-loader');\n    const { isLoadContentResult } = await import('@core/types/load-content');\n    \n    let loadResult: any;\n    try {\n      // If we already have a resolved path (from variable interpolation), create a simple path source\n      const sourceToUse = resolvedPath !== node.source?.raw ? \n        { type: 'path', raw: resolvedPath, segments: [{ type: 'Text', content: resolvedPath }] } : \n        node.source;\n      \n      loadResult = await processContentLoader({\n        type: 'load-content',\n        source: sourceToUse\n      }, env);\n    } catch (error: any) {\n      // Handle file not found or access errors gracefully by returning empty string\n      if (error.code === 'ENOENT') {\n        console.error(`Warning: File not found - '${resolvedPath}'`);\n\n        // Check for failed variable interpolation\n        if (resolvedPath.includes('@')) {\n          const varMatches = resolvedPath.match(/@(\\w+)/g);\n          if (varMatches && varMatches.length > 0) {\n            console.error('');\n            for (const match of varMatches) {\n              const varName = match.substring(1);\n              try {\n                const actualValue = env.getVariable(varName);\n                const valueType = actualValue?.type || typeof actualValue;\n                const valuePreview = JSON.stringify(actualValue, null, 2).substring(0, 200);\n                console.error(`Variable @${varName} is a ${valueType} containing:`);\n                console.error(valuePreview);\n              } catch {\n                console.error(`Variable @${varName} is not in scope or failed to retrieve.`);\n              }\n            }\n            console.error(`\\nContent loaders like <path> need a string path or array of paths.`);\n            console.error(`Did you mean to use the variable directly (without angle brackets)?`);\n            console.error('');\n          }\n        } else if (!resolvedPath.startsWith('/') && !resolvedPath.startsWith('@')) {\n          // Check if the path looks like it might be relative\n          console.error(`Hint: Paths are relative to mlld files. You can make them relative to your project root with the \\`@base/\\` prefix`);\n        }\n        return '';\n      } else if (error.code === 'EACCES') {\n        console.error(`Warning: Permission denied - '${resolvedPath}'`);\n        return '';\n      } else {\n        console.error(`Warning: Failed to load file '${resolvedPath}': ${error.message}`);\n\n        // Check for angle bracket in path (likely XML/HTML context)\n        const hasAngleBracket = resolvedPath.includes('<') || resolvedPath.includes('>');\n        if (hasAngleBracket) {\n          console.error('');\n          console.error('This looks like you tried to use alligator field access inside XML/HTML tags.');\n          console.error('Due to grammar ambiguity with nested angle brackets, this pattern is not supported.');\n          console.error('');\n          console.error('Workaround: Use a variable instead:');\n          console.error('  /var @file = <file.md>.keep');\n          console.error('  /show `<@file.mx.filename>@file</@file.mx.filename>`');\n          console.error('');\n          return '';\n        }\n\n        // Check for failed variable interpolation\n        let hasVariableHint = false;\n        if (resolvedPath.includes('@')) {\n          const varMatches = resolvedPath.match(/@(\\w+)/g);\n          if (varMatches && varMatches.length > 0) {\n            hasVariableHint = true;\n            console.error('');\n            for (const match of varMatches) {\n              const varName = match.substring(1);\n              try {\n                const actualValue = env.getVariable(varName);\n                const valueType = actualValue?.type || typeof actualValue;\n                const valuePreview = JSON.stringify(actualValue, null, 2).substring(0, 200);\n                console.error(`Variable @${varName} is a ${valueType} containing:`);\n                console.error(valuePreview);\n              } catch {\n                console.error(`Variable @${varName} is not in scope or failed to retrieve.`);\n              }\n            }\n            console.error(`\\nContent loaders like <path> need a string path or array of paths.`);\n            console.error(`Did you mean to use the variable directly (without angle brackets)?`);\n            console.error('');\n          }\n        }\n\n        // Check if the path looks like it might be relative (only if no other hint shown)\n        if (!hasVariableHint && !resolvedPath.startsWith('/') && !resolvedPath.startsWith('@')) {\n          console.error(`Hint: Paths are relative to mlld files. You can make them relative to your project root with the \\`@base/\\` prefix`);\n        }\n        return '';\n      }\n    }\n    \n    // Handle glob results (array of files)\n    if (isStructuredValue(loadResult) && loadResult.type === 'array') {\n      // For glob patterns, process each file and join all file contents\n      const items = loadResult.data as LoadContentResult[];\n      const contents = await Promise.all(\n        items.map(file => processFileFields(file, node.fields, node.pipes, env))\n      );\n      return contents.join('\\n\\n');\n    }\n    \n    // Process field access and pipes\n    return processFileFields(loadResult, node.fields, node.pipes, env);\n  } finally {\n    // Remove from stack\n    env.popInterpolationStack(resolvedPath);\n  }\n}\n\n/**\n * Process field access and pipes on file content\n */\nexport async function processFileFields(\n  content: LoadContentResult | LoadContentResult[],\n  fields: FieldAccessNode[] | undefined,\n  pipes: CondensedPipe[] | undefined,\n  env: Environment\n): Promise<string> {\n  const { isLoadContentResult } = await import('@core/types/load-content');\n  let result: any = content;\n  \n  // Keep LoadContentResult intact for field access, only extract content if no fields to access\n  if (isLoadContentResult(result)) {\n    if (!fields || fields.length === 0) {\n      // No field access needed, extract content\n      result = asText(result);\n    }\n    // If we have fields to access, keep the full LoadContentResult object so we can access .fm, .json, etc.\n  }\n  \n  // Process field access\n  if (fields && fields.length > 0) {\n    // Use enhanced field access for better error messages\n    const { accessField } = await import('../utils/field-access');\n    for (const field of fields) {\n      try {\n        const fieldResult = await accessField(result, field, { \n          preserveContext: true,\n          env \n        });\n        result = (fieldResult as any).value;\n        if (result === undefined) {\n          // Warning to stderr\n          console.error(`Warning: field '${field.value}' not found`);\n          return '';\n        }\n      } catch (error) {\n        // Field not found - log warning and return empty string for backward compatibility\n        console.error(`Warning: field '${field.value}' not found`);\n        return '';\n      }\n    }\n  }\n  \n  // Apply pipes\n  if (pipes && pipes.length > 0) {\n    // Use unified pipeline processor instead of applyCondensedPipes\n    const { processPipeline } = await import('../eval/pipeline/unified-processor');\n    // Create a node object with the pipes for the processor\n    const nodeWithPipes = { pipes };\n    result = await processPipeline({\n      value: result,\n      env,\n      node: nodeWithPipes\n    });\n    // Pipes already handle conversion to string format, so return as-is\n    return asText(result);\n  }\n  \n  // Convert to string only if no pipes were applied\n  if (isStructuredValue(result)) {\n    return asText(result);\n  }\n  return typeof result === 'string' ? result : JSON.stringify(result);\n}\n","import type { \n  MlldNode, \n  DirectiveNode, \n  TextNode, \n  CommentNode, \n  MlldDocument, \n  FrontmatterNode, \n  VariableReferenceNode,\n  CodeFenceNode,\n  NewlineNode,\n  ErrorNode,\n  LiteralNode,\n  DotSeparatorNode,\n  PathSeparatorNode,\n  SectionMarkerNode,\n  ExecInvocation,\n  BaseMlldNode,\n  FileReferenceNode,\n  FieldAccessNode,\n  CondensedPipe\n} from '@core/types';\nimport { astLocationToSourceLocation } from '@core/types';\nimport type { Variable } from '@core/types/variable';\nimport type { Environment } from '../env/Environment';\nimport { evaluateDirective } from '../eval/directive';\nimport type { VarAssignmentResult } from '../eval/var';\nimport { isExecInvocation, isLiteralNode } from '@core/types';\nimport { evaluateDataValue, isFullyEvaluated, collectEvaluationErrors } from '../eval/data-value-evaluator';\nimport { InterpolationContext, EscapingStrategyFactory } from './interpolation-context';\nimport { parseFrontmatter } from '../utils/frontmatter-parser';\nimport type { OperationContext } from '../env/ContextManager';\nimport { interpreterLogger as logger } from '@core/utils/logger';\nimport { asText, assertStructuredValue } from '@interpreter/utils/structured-value';\nimport { materializeDisplayValue } from '../utils/display-materialization';\nimport type { SecurityDescriptor } from '@core/types/security';\nimport { classifyShellValue } from '@interpreter/utils/shell-value';\nimport {\n  createInterpolator,\n  extractInterpolationDescriptor,\n  interpolateFileReference,\n  processFileFields,\n  type InterpolateOptions,\n  type InterpolationNode\n} from '../utils/interpolation';\nimport * as shellQuote from 'shell-quote';\n\n/**\n * Type for variable values\n */\nexport type VariableValue = string | number | boolean | null | \n                           VariableValue[] | { [key: string]: VariableValue };\n\nexport { interpolateFileReference, processFileFields };\n\n/**\n * Field access types from the AST\n */\ninterface FieldAccess {\n  type: 'field' | 'arrayIndex' | 'numericField' | 'stringIndex';\n  value: string | number;\n}\n\n/**\n * Safe field access helper\n */\nfunction accessField(value: unknown, field: FieldAccess): unknown {\n  if (value === null || value === undefined) {\n    return undefined;\n  }\n  \n  if (field.type === 'arrayIndex') {\n    if (!Array.isArray(value)) {\n      return undefined;\n    }\n    const index = Number(field.value);\n    if (isNaN(index) || index < 0 || index >= value.length) {\n      return undefined;\n    }\n    return value[index];\n  } else if (field.type === 'field' || field.type === 'stringIndex' || field.type === 'numericField') {\n    if (typeof value !== 'object' || Array.isArray(value)) {\n      return undefined;\n    }\n    const name = String(field.value);\n    return (value as Record<string, unknown>)[name];\n  }\n  \n  return undefined;\n}\n\n/**\n * Type guards for AST nodes\n */\nfunction isDocument(node: MlldNode): node is DocumentNode {\n  return node.type === 'Document';\n}\n\nfunction isDirective(node: MlldNode): node is DirectiveNode {\n  return node.type === 'Directive';\n}\n\nfunction isText(node: MlldNode): node is TextNode {\n  return node.type === 'Text';\n}\n\nfunction isNewline(node: MlldNode): node is NewlineNode {\n  return node.type === 'Newline';\n}\n\nfunction isComment(node: MlldNode): node is CommentNode {\n  return node.type === 'Comment';\n}\n\nfunction isFrontmatter(node: MlldNode): node is FrontmatterNode {\n  return node.type === 'Frontmatter';\n}\n\nfunction isCodeFence(node: MlldNode): node is CodeFenceNode {\n  return node.type === 'CodeFence';\n}\n\nfunction isMlldRunBlock(node: MlldNode): node is MlldRunBlockNode {\n  return node.type === 'MlldRunBlock';\n}\n\nfunction isVariableReference(node: MlldNode): node is VariableReferenceNode {\n  return node.type === 'VariableReference';\n}\n\nfunction isError(node: MlldNode): node is ErrorNode {\n  return node.type === 'Error';\n}\n\nfunction isDotSeparator(node: MlldNode): node is DotSeparatorNode {\n  return node.type === 'DotSeparator';\n}\n\nfunction isPathSeparator(node: MlldNode): node is PathSeparatorNode {\n  return node.type === 'PathSeparator';\n}\n\nfunction isSectionMarker(node: MlldNode): node is SectionMarkerNode {\n  return node.type === 'SectionMarker';\n}\n\n/**\n * Frontmatter data type\n */\ntype FrontmatterData = Record<string, unknown> | null;\n\n/**\n * Document node type (if not defined in core types)\n */\ninterface DocumentNode extends BaseMlldNode {\n  type: 'Document';\n  nodes: MlldNode[];\n}\n\n/**\n * MlldRunBlock node type\n */\ninterface MlldRunBlockNode extends BaseMlldNode {\n  type: 'MlldRunBlock';\n  content: MlldNode[];\n  raw: string;\n  error?: string;\n}\n\n// Use DocumentNode if MlldDocument is not properly defined\ntype MlldDocumentType = MlldDocument extends never ? DocumentNode : MlldDocument;\n\n/**\n * Path value type\n */\ninterface PathValue {\n  resolvedPath: string;\n}\n\n/**\n * Type guard for path values\n */\nfunction isPathValue(value: unknown): value is PathValue {\n  return typeof value === 'object' && \n         value !== null && \n         'resolvedPath' in value &&\n         typeof (value as PathValue).resolvedPath === 'string';\n}\n\n\n/**\n * Core evaluation result type\n */\nexport interface EvalResult {\n  value: unknown;\n  env: Environment;\n  stdout?: string;\n  stderr?: string;\n  exitCode?: number;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Evaluation context options\n */\nexport interface EvaluationContext {\n  /** Whether we're evaluating a condition (affects field access behavior) */\n  isCondition?: boolean;\n  /** Whether we're evaluating an expression (affects variable resolution) */\n  isExpression?: boolean;\n  /** Pre-evaluated directive inputs supplied by hook extraction */\n  extractedInputs?: readonly unknown[];\n  /** Operation context captured for the active directive */\n  operationContext?: OperationContext;\n  /** Precomputed /var assignment (Phase C guard runner) */\n  precomputedVarAssignment?: VarAssignmentResult;\n}\n\n/**\n * Main recursive evaluation function.\n * This is the heart of the interpreter - it walks the AST and evaluates each node.\n */\nexport async function evaluate(node: MlldNode | MlldNode[], env: Environment, context?: EvaluationContext): Promise<EvalResult> {\n  // Handle array of nodes (from parser)\n  if (Array.isArray(node)) {\n    let lastValue: unknown = undefined;\n    let lastResult: EvalResult | null = null;\n    \n    // First, check if the first node is frontmatter and process it\n    if (node.length > 0 && isFrontmatter(node[0])) {\n      const frontmatterNode = node[0];\n      const frontmatterData: FrontmatterData = parseFrontmatter(frontmatterNode.content);\n      env.setFrontmatter(frontmatterData);\n      \n      // Process remaining nodes\n      for (let i = 1; i < node.length; i++) {\n        const n = node[i];\n        const result = await evaluate(n, env, context);\n        lastValue = result.value;\n        lastResult = result;\n        \n        // Emit effects for non-directive nodes to preserve document structure\n        // Skip effect emission when evaluating expressions (they're not document content)\n        if (!isDirective(n) && !context?.isExpression) {\n          // Skip inline comments (lines starting with >> or <<)\n          if (isText(n) && n.content.trimStart().match(/^(>>|<<)/)) {\n            continue;\n          }\n          // Skip comment nodes\n          if (isComment(n)) {\n            logger.debug('Skipping comment node:', { content: n.content });\n            continue;\n          }\n          // Emit intents for non-directive nodes (preserves document structure with break collapsing)\n          if (isText(n)) {\n            // If Text node contains only newlines, emit as collapsible breaks\n            if (/^\\n+$/.test(n.content)) {\n              for (let i = 0; i < n.content.length; i++) {\n                env.emitIntent({\n                  type: 'break',\n                  value: '\\n',\n                  source: 'newline',\n                  visibility: 'always',\n                  collapsible: true\n                });\n              }\n            } else {\n              const materialized = materializeDisplayValue(n.content, undefined, n.content);\n              env.emitIntent({\n                type: 'content',\n                value: materialized.text,\n                source: 'text',\n                visibility: 'always',\n                collapsible: false\n              });\n              if (materialized.descriptor) {\n                env.recordSecurityDescriptor(materialized.descriptor);\n              }\n            }\n          } else if (isNewline(n)) {\n            env.emitIntent({\n              type: 'break',\n              value: '\\n',\n              source: 'newline',\n              visibility: 'always',\n              collapsible: true\n            });\n          } else if (isCodeFence(n)) {\n            const materialized = materializeDisplayValue(n.content, undefined, n.content);\n            env.emitIntent({\n              type: 'content',\n              value: materialized.text,\n              source: 'text',\n              visibility: 'always',\n              collapsible: false\n            });\n            if (materialized.descriptor) {\n              env.recordSecurityDescriptor(materialized.descriptor);\n            }\n          } else if (isMlldRunBlock(n) && !n.error) {\n            // MlldRunBlock content is evaluated, not emitted directly\n            // The evaluation will emit its own effects\n          } else if ('wrapperType' in n && 'content' in n) {\n            // Template structures are intermediate nodes, not document content\n            // They get evaluated but shouldn't be emitted as effects\n          } else {\n            // For other node types, emit their content as 'doc' effect\n            // Skip other node types - they're AST nodes, not document content\n            // This includes ExecInvocation, VariableReference, Literal, etc.\n            // These are intermediate representations that get evaluated but not emitted\n            logger.debug('Skipping non-document node type:', { type: (n as any).type });\n          }\n        }\n        \n        // Add all nodes to environment for document reconstruction\n        // This enables /output directive to recreate the complete document\n        if (!context?.isExpression) {\n          env.addNode(n);\n        }\n      }\n    } else {\n      // No frontmatter, process all nodes normally\n      for (const n of node) {\n        const result = await evaluate(n, env, context);\n        lastValue = result.value;\n        lastResult = result;\n\n        // Add all nodes to environment for document reconstruction\n        // This enables /output directive to recreate the complete document\n        if (!context?.isExpression) {\n          env.addNode(n);\n        }\n        \n        // Emit effects for non-directive nodes to preserve document structure\n        // Skip effect emission when evaluating expressions (they're not document content)\n        if (!isDirective(n) && !context?.isExpression) {\n          // Skip inline comments (lines starting with >> or <<)\n          if (isText(n) && n.content.trimStart().match(/^(>>|<<)/)) {\n            continue;\n          }\n          // Skip comment nodes\n          if (isComment(n)) {\n            logger.debug('Skipping comment node:', { content: n.content });\n            continue;\n          }\n          // Emit intents for non-directive nodes (preserves document structure with break collapsing)\n          if (isText(n)) {\n            // If Text node contains only newlines, emit as collapsible breaks\n            if (/^\\n+$/.test(n.content)) {\n              for (let i = 0; i < n.content.length; i++) {\n                env.emitIntent({\n                  type: 'break',\n                  value: '\\n',\n                  source: 'newline',\n                  visibility: 'always',\n                  collapsible: true\n                });\n              }\n            } else {\n              const materialized = materializeDisplayValue(n.content, undefined, n.content);\n              env.emitIntent({\n                type: 'content',\n                value: materialized.text,\n                source: 'text',\n                visibility: 'always',\n                collapsible: false\n              });\n              if (materialized.descriptor) {\n                env.recordSecurityDescriptor(materialized.descriptor);\n              }\n            }\n          } else if (isNewline(n)) {\n            env.emitIntent({\n              type: 'break',\n              value: '\\n',\n              source: 'newline',\n              visibility: 'always',\n              collapsible: true\n            });\n          } else if (isCodeFence(n)) {\n            const materialized = materializeDisplayValue(n.content, undefined, n.content);\n            env.emitIntent({\n              type: 'content',\n              value: materialized.text,\n              source: 'text',\n              visibility: 'always',\n              collapsible: false\n            });\n            if (materialized.descriptor) {\n              env.recordSecurityDescriptor(materialized.descriptor);\n            }\n          } else if (isMlldRunBlock(n) && !n.error) {\n            // MlldRunBlock content is evaluated, not emitted directly\n            // The evaluation will emit its own effects\n          } else if ('wrapperType' in n && 'content' in n) {\n            // Template structures are intermediate nodes, not document content\n            // They get evaluated but shouldn't be emitted as effects\n          } else {\n            // For other node types, emit their content as 'doc' effect\n            // Skip other node types - they're AST nodes, not document content\n            // This includes ExecInvocation, VariableReference, Literal, etc.\n            // These are intermediate representations that get evaluated but not emitted\n            logger.debug('Skipping non-document node type:', { type: (n as any).type });\n          }\n        }\n      }\n    }\n    \n    // Return the last result with all its properties (including stdout, stderr, exitCode)\n    if (lastResult && (lastResult.stdout !== undefined || lastResult.stderr !== undefined || lastResult.exitCode !== undefined)) {\n      return lastResult;\n    }\n    \n    return { value: lastValue, env };\n  }\n  \n  // Handle single node\n  \n  // Handle all template/quote structures from unified patterns\n  // These have either content or values.content arrays that need interpolation\n  if (!Array.isArray(node) && node && typeof node === 'object') {\n    // Check for template structures with content to interpolate\n    let contentToInterpolate = null;\n    \n    // Pattern 1: Direct content with wrapperType (from UnifiedQuoteOrTemplate)\n    if ('content' in node && Array.isArray(node.content) && 'wrapperType' in node && !node.type) {\n      contentToInterpolate = node.content;\n    }\n    // Pattern 2: Template nodes with type field (from TemplateCore and directives)\n    else if (node.type === 'template' && node.values?.content && Array.isArray(node.values.content)) {\n      contentToInterpolate = node.values.content;\n    }\n    // Pattern 3: Template nodes with direct content field\n    else if (node.type === 'template' && node.content && Array.isArray(node.content)) {\n      contentToInterpolate = node.content;\n    }\n    \n    if (contentToInterpolate) {\n      const interpolated = await interpolateWithSecurityRecording(contentToInterpolate, env);\n      return { value: interpolated, env };\n    }\n  }\n  \n  if (isDocument(node)) {\n    return evaluateDocument(node, env);\n  }\n  \n  if (isDirective(node)) {\n    return evaluateDirective(node, env, context);\n  }\n  \n  if (isText(node)) {\n    return evaluateText(node, env);\n  }\n  \n  if (isNewline(node)) {\n    // Newline nodes are already added by the array processing logic\n    return { value: '\\n', env };\n  }\n  \n  if (isComment(node)) {\n    // Comments are NOT included in output\n    // Skip comments - don't add any nodes to output\n    return { value: node.content, env };\n  }\n  \n  if (isFrontmatter(node)) {\n    // Process frontmatter node\n    const frontmatterData: FrontmatterData = parseFrontmatter(node.content);\n    env.setFrontmatter(frontmatterData);\n    return { value: frontmatterData, env };\n  }\n  \n  if (isCodeFence(node)) {\n    // Emit code fence content as content intent\n    env.emitIntent({\n      type: 'content',\n      value: node.content,\n      source: 'text',\n      visibility: 'always',\n      collapsible: false\n    });\n    return { value: node.content, env };\n  }\n  \n  if (isMlldRunBlock(node)) {\n    // Handle mlld-run blocks by evaluating their content\n    if (node.error) {\n      // If there was a parse error, output it as text\n      // Emit error as error intent\n      env.emitIntent({\n        type: 'error',\n        value: `Error in mlld-run block: ${node.error}`,\n        source: 'directive',\n        visibility: 'always',\n        collapsible: false\n      });\n      return { value: node.error, env };\n    }\n    \n    // Evaluate the parsed content\n    const result = await evaluate(node.content, env, context);\n    return result;\n  }\n      \n  if (isVariableReference(node)) {\n    // Variable references are handled by interpolation in context\n    // If we get here, it's likely an error or a grammar bug\n    \n    // TODO: Remove this workaround when issue #50 is fixed\n    // The grammar incorrectly creates top-level VariableReference nodes\n    // for parameters in exec directives. These have location offset 0,0\n    // which is impossible for real variable references.\n    interface LocationWithOffset {\n      start?: { offset?: number };\n      end?: { offset?: number };\n    }\n    \n    function hasValidLocation(loc: unknown): loc is LocationWithOffset {\n      return typeof loc === 'object' && loc !== null && 'start' in loc && 'end' in loc;\n    }\n    \n    const location: unknown = node.location;\n    const hasZeroOffset = hasValidLocation(location) &&\n                         location.start?.offset === 0 && \n                         location.end?.offset === 0;\n    if (hasZeroOffset &&\n        node.valueType !== 'commandRef' &&\n        node.valueType !== 'varIdentifier' &&\n        // Allow ambient @mx to resolve even if parser produced zero offsets\n        node.identifier !== 'mx') {\n      // Skip orphaned parameter references from grammar bug\n      // Note: varIdentifier is excluded because when conditions create these\n      // See issue #217 - this workaround prevents when conditions from working\n      return { value: '', env };\n    }\n    \n    // Built-in functions removed - use @exec to define custom functions instead\n    \n    let variable = env.getVariable(node.identifier);\n    \n    // Check if this is a resolver variable that needs async resolution\n    if (!variable && env.hasVariable(node.identifier)) {\n      // Try to get it as a resolver variable\n      const resolverVar = await env.getResolverVariable(node.identifier);\n      if (resolverVar) {\n        variable = resolverVar;\n      }\n    }\n    \n    if (!variable) {\n      // In expression context, return undefined for missing variables\n      if (context?.isExpression) {\n        return { value: undefined, env };\n      }\n      throw new Error(`Variable not found: ${node.identifier}`);\n    }\n    \n    // Handle command references (e.g., @is_true() in conditions)\n    if (node.valueType === 'commandRef' && isCommandVariable(variable)) {\n      // Execute the command\n      const args: unknown[] = (node as { args?: unknown[] }).args || [];\n      \n      // Check the structure - new vs old command variable format\n      const definition = (variable as { definition?: unknown }).definition || variable.value;\n      \n      if (!definition) {\n        throw new Error(`Command variable ${node.identifier} has no definition`);\n      }\n      \n      // Type guard for command definition\n      if (typeof definition === 'object' && definition !== null && 'type' in definition) {\n        const typedDef = definition as { type: string; commandTemplate?: MlldNode[]; codeTemplate?: MlldNode[]; language?: string; command?: MlldNode[]; code?: MlldNode[] };\n        \n        if (typedDef.type === 'command') {\n          // Execute command with interpolated template\n          const commandTemplate = typedDef.commandTemplate || typedDef.command;\n          if (!commandTemplate) {\n            throw new Error(`Command ${node.identifier} has no command template`);\n          }\n          \n          // Interpolate the command template\n          const command = await interpolateWithSecurityRecording(commandTemplate as InterpolationNode[], env);\n          \n          if (args.length > 0) {\n            // TODO: Implement proper argument interpolation\n            // For now, just use the command as-is\n          }\n          \n          const stdout = await env.executeCommand(command);\n          return {\n            value: stdout,\n            env,\n            stdout: stdout,\n            stderr: '',\n            exitCode: 0  // executeCommand only returns on success\n          };\n        } else if (typedDef.type === 'code') {\n          // Execute code with interpolated template\n          const codeTemplate = typedDef.codeTemplate || typedDef.code;\n          if (!codeTemplate) {\n            throw new Error(`Code command ${node.identifier} has no code template`);\n          }\n          \n          // Interpolate the code template\n          const code = await interpolateWithSecurityRecording(codeTemplate as InterpolationNode[], env);\n          \n          const result = await env.executeCode(\n            code,\n            typedDef.language || 'javascript'\n          );\n          return {\n            value: result,\n            env,\n            stdout: result,\n            stderr: '',\n            exitCode: 0\n          };\n        }\n      }\n    }\n    \n    /**\n     * Preserve Variable wrapper for field access operations\n     * WHY: Field access needs Variable metadata to properly resolve complex data\n     *      structures and maintain access path information\n     */\n    const { resolveVariable, ResolutionContext } = await import('../utils/variable-resolution');\n    \n    // Check if we're in an expression context that needs raw values\n    const isInExpression = context && context.isExpression;\n    const hasFieldAccess = Array.isArray(node.fields) && node.fields.length > 0;\n    const resolutionContext =\n      hasFieldAccess ? ResolutionContext.FieldAccess\n      : isInExpression ? ResolutionContext.Equality\n      : ResolutionContext.FieldAccess;\n    \n    let resolvedValue = await resolveVariable(variable, env, resolutionContext);\n    \n    // Handle field access if present\n    if (node.fields && node.fields.length > 0) {\n      const { accessField } = await import('../utils/field-access');\n      const fieldAccessLocation = astLocationToSourceLocation(node.location, env.getCurrentFilePath());\n      \n      // accessField handles Variable extraction internally when needed\n      // No need to manually extract here\n      \n      // Apply each field access in sequence\n      for (const field of node.fields) {\n        const fieldResult = await accessField(resolvedValue, field, { \n          preserveContext: true,\n          returnUndefinedForMissing: context?.isCondition,\n          env,\n          sourceLocation: fieldAccessLocation\n        });\n        resolvedValue = (fieldResult as any).value;\n        if (resolvedValue === undefined) break;\n      }\n    }\n    \n    // Apply condensed pipes if present (same as in interpolate)\n    if (node.pipes && node.pipes.length > 0) {\n      const { processPipeline } = await import('../eval/pipeline/unified-processor');\n      resolvedValue = await processPipeline({\n        value: resolvedValue,\n        env,\n        node,\n        identifier: node.identifier\n      });\n    }\n    \n    return { value: resolvedValue, env };\n  }\n  \n  if (isExecInvocation(node)) {\n    // Import the exec invocation evaluator\n    const { evaluateExecInvocation } = await import('../eval/exec-invocation');\n    return evaluateExecInvocation(node, env);\n  }\n\n  // Handle VariableReferenceWithTail (variable with pipeline from when-expression actions)\n  if (node.type === 'VariableReferenceWithTail') {\n    const { VariableReferenceEvaluator } = await import('../eval/data-values/VariableReferenceEvaluator');\n    const evaluator = new VariableReferenceEvaluator();\n    const result = await evaluator.evaluate(node, env);\n    return { value: result, env };\n  }\n\n  // Handle expression nodes\n  if (node.type === 'BinaryExpression' || node.type === 'TernaryExpression' || node.type === 'UnaryExpression') {\n    const { evaluateUnifiedExpression } = await import('../eval/expressions');\n    const result = await evaluateUnifiedExpression(node, env);\n    return { value: result.value, env };\n  }\n  \n  // Handle literal nodes\n  if (isLiteralNode(node)) {\n    // Check for retry literal\n    if (node.valueType === 'retry') {\n      // Check if we're in pipeline context\n      const pipelineCtx = env.getPipelineContext();\n      if (!pipelineCtx) {\n        throw new Error('retry keyword used outside pipeline context');\n      }\n      return { value: 'retry', env };\n    }\n\n    if (node.valueType === 'done' || node.valueType === 'continue') {\n      return { value: node, env };\n    }\n    \n    return { value: node.value, env };\n  }\n  \n  // Handle when expressions\n  if (node.type === 'WhenExpression') {\n    const { evaluateWhenExpression } = await import('../eval/when-expression');\n    return evaluateWhenExpression(node as any, env, context);\n  }\n\n  if (node.type === 'ExeBlock') {\n    const { evaluateExeBlock } = await import('../eval/exe');\n    return evaluateExeBlock(node as any, env);\n  }\n  \n  // Handle foreach expressions as first-class expressions\n  if (node.type === 'foreach' || node.type === 'foreach-command') {\n    const { evaluateForeachCommand } = await import('../eval/foreach');\n    const result = await evaluateForeachCommand(node as any, env);\n    return { value: result, env };\n  }\n  \n  // Note: WhenRHSAction nodes have been replaced with regular Directive nodes\n  // that get evaluated through the normal directive evaluation path below\n  \n  // Handle for expressions\n  if (node.type === 'ForExpression') {\n    const { evaluateForExpression } = await import('../eval/for');\n    const result = await evaluateForExpression(node as any, env);\n    return { value: result, env };\n  }\n  \n  // Handle data value nodes from the grammar (arrays and objects)\n  if (node.type === 'array' || node.type === 'object') {\n    // These are data value nodes that need to be evaluated\n    const result = await evaluateDataValue(node, env);\n    return { value: result, env };\n  }\n\n  // Handle load-content nodes (alligator syntax: <file>)\n  if (node.type === 'load-content') {\n    const result = await evaluateDataValue(node, env);\n    return { value: result, env };\n  }\n\n  // Handle FileReference nodes (<file> with field access or pipes)\n  if (node.type === 'FileReference') {\n    const fileRefNode = node as FileReferenceNode;\n    const { processContentLoader } = await import('../eval/content-loader');\n    const { accessField } = await import('../utils/field-access');\n    const { wrapLoadContentValue } = await import('../utils/load-content-structured');\n    const { isStructuredValue } = await import('../utils/structured-value');\n\n    // Convert FileReference to load-content structure\n    const loadContentNode = {\n      type: 'load-content' as const,\n      source: fileRefNode.source\n    };\n\n    // Load the content\n    const rawLoadResult = await processContentLoader(loadContentNode, env);\n    let loadResult = isStructuredValue(rawLoadResult)\n      ? rawLoadResult\n      : wrapLoadContentValue(rawLoadResult);\n\n    // Process field access if present\n    if (fileRefNode.fields && fileRefNode.fields.length > 0) {\n      let result: any = loadResult;\n      for (const field of fileRefNode.fields) {\n        result = await accessField(result, field, { env });\n      }\n      return { value: result, env };\n    }\n\n    return { value: loadResult, env };\n  }\n\n  // Handle command nodes (from run {command} in expressions)\n  if (node.type === 'command') {\n    // Reuse the same logic as in lazy-eval.ts\n    let commandStr: string;\n    if (typeof node.command === 'string') {\n      commandStr = node.command || '';\n    } else if (Array.isArray(node.command)) {\n      // Interpolate the command array\n      const interpolatedCommand = await interpolateWithSecurityRecording(node.command, env);\n      commandStr = interpolatedCommand || '';\n    } else {\n      commandStr = '';\n    }\n    \n    // Execute command if it has the run keyword\n    if (node.hasRunKeyword) {\n      const result = await env.executeCommand(commandStr);\n      return { value: result, env };\n    }\n    \n    // Command without run keyword - return as-is (shouldn't happen in practice)\n    return { value: commandStr, env };\n  }\n  \n  // If we get here, it's an unknown node type\n  throw new Error(`Unknown node type: ${node.type}`);\n}\n\nconst interpolate = createInterpolator(() => ({ evaluate }));\nexport { interpolate };\n\nasync function interpolateWithSecurityRecording(\n  nodes: any,\n  env: Environment,\n  context?: InterpolationContext\n): Promise<string> {\n  const descriptors: SecurityDescriptor[] = [];\n  const text = await interpolate(nodes, env, context, {\n    collectSecurityDescriptor: descriptor => {\n      if (descriptor) {\n        descriptors.push(descriptor);\n      }\n    }\n  });\n  if (descriptors.length > 0) {\n    const merged =\n      descriptors.length === 1\n        ? descriptors[0]\n        : env.mergeSecurityDescriptors(...descriptors);\n    env.recordSecurityDescriptor(merged);\n  }\n  return text;\n}\n\n/**\n * Evaluate a document node (contains multiple child nodes)\n */\nasync function evaluateDocument(doc: DocumentNode, env: Environment): Promise<EvalResult> {\n  let lastValue: unknown = undefined;\n  \n  // Evaluate each child node in sequence\n  for (const child of doc.nodes) {\n    const result = await evaluate(child, env, context);\n    lastValue = result.value;\n    \n    // Emit text nodes as content intents\n    if (isText(child)) {\n      env.emitIntent({\n        type: 'content',\n        value: child.content,\n        source: 'text',\n        visibility: 'always',\n        collapsible: false\n      });\n    }\n    // VariableReference nodes are handled consistently through interpolate()\n  }\n  \n  return { value: lastValue, env };\n}\n\n/**\n * Evaluate a text node (just plain text, no processing needed)\n */\nasync function evaluateText(node: TextNode, env: Environment): Promise<EvalResult> {\n  // Text nodes are simple - their content is their value\n  return { value: node.content, env };\n}\n\n/**\n * Resolve variable value with lazy evaluation support for complex data\n */\nasync function resolveVariableValue(variable: Variable, env: Environment): Promise<VariableValue> {\n  // Import type guards for the new Variable type system\n  const {\n    isTextLike,\n    isStructured,\n    isPath,\n    isPipelineInput,\n    isExecutable,\n    isExecutableVariable,\n    isImported,\n    isComputed,\n    isObject,\n    isArray,\n    isPrimitive\n  } = await import('@core/types/variable');\n  \n  // Type-specific resolution using new type guards\n  if (isPrimitive(variable)) {\n    // Primitive variables return their raw value (number, boolean, null)\n    return variable.value;\n  } else if (isTextLike(variable)) {\n    // All text-producing types return their string value directly\n    return variable.value;\n  } else if (isStructured(variable)) {\n    // Object and array variables\n    const complexFlag = (variable as any).isComplex;\n    \n    // Debug logging for object resolution\n    if (process.env.DEBUG_EXEC) {\n      logger.debug('resolveVariableValue for structured variable:', {\n        variableName: variable.name,\n        variableType: variable.type,\n        isComplex: complexFlag,\n        valueType: typeof variable.value,\n        hasTypeProperty: variable.value && typeof variable.value === 'object' && 'type' in variable.value\n      });\n    }\n    \n    \n    if (complexFlag) {\n      // Complex data needs evaluation\n      \n      const evaluatedValue = await evaluateDataValue(variable.value, env);\n      \n      // Debug logging\n      \n      return evaluatedValue;\n    }\n    \n    // Don't clean namespace objects here - they need to remain as objects\n    // for field access to work. Cleaning should only happen during display.\n    \n    return variable.value;\n  } else if (isPath(variable)) {\n    // Path variables return the resolved path string\n    return variable.value.resolvedPath;\n  } else if (isPipelineInput(variable)) {\n    // Pipeline inputs return the text representation by default\n    assertStructuredValue(variable.value, 'interpolate:pipeline-input');\n    return asText(variable.value);\n  } else if (isExecutableVariable(variable)) {\n    // Auto-execute executables when interpolated\n    if (process.env.DEBUG_EXEC) {\n      logger.debug('Auto-executing executable during interpolation:', { name: variable.name });\n    }\n    const { evaluateExecInvocation } = await import('../eval/exec-invocation');\n    const invocation = {\n      type: 'ExecInvocation',\n      commandRef: {\n        identifier: variable.name,\n        args: []\n      }\n    };\n    const result = await evaluateExecInvocation(invocation as any, env);\n    return result.value;\n  } else if (isImported(variable)) {\n    return variable.value;\n  } else if (isComputed(variable)) {\n    return variable.value;\n  }\n  \n  // Fallback - should not reach here with proper typing\n  return variable.value;\n}\n\n/**\n * Clean up namespace objects for display\n * Shows only frontmatter and exported variables, not internal structure\n */\nexport function cleanNamespaceForDisplay(namespaceObject: any): string {\n  const cleaned: any = {\n    frontmatter: {},\n    exports: {\n      variables: {},\n      executables: {}\n    }\n  };\n  \n  // Add frontmatter if present\n  const fm = namespaceObject.fm || namespaceObject.frontmatter || namespaceObject.__meta__;\n  if (fm && Object.keys(fm).length > 0) {\n    cleaned.frontmatter = fm;\n  }\n  \n  // Separate variables and executables\n  const internalFields = ['fm', 'frontmatter', '__meta__'];\n  let hasExports = false;\n  \n  for (const [key, value] of Object.entries(namespaceObject)) {\n    if (!internalFields.includes(key)) {\n      hasExports = true;\n      // Check if it's an executable\n      if (value && typeof value === 'object' && (value as any).__executable) {\n        const params = (value as any).paramNames || [];\n        cleaned.exports.executables[key] = `<function(${params.join(', ')})>`;\n      } else if (value && typeof value === 'object' && value.type === 'executable') {\n        // Alternative executable format\n        const def = value.value || value.definition;\n        const params = def?.paramNames || [];\n        cleaned.exports.executables[key] = `<function(${params.join(', ')})>`;\n      } else {\n        // Regular variable - extract just the value, not the whole AST\n        if (value && typeof value === 'object' && value.value !== undefined) {\n          // This is a Variable object with a value property\n          cleaned.exports.variables[key] = value.value;\n        } else {\n          // Direct value\n          cleaned.exports.variables[key] = value;\n        }\n      }\n    }\n  }\n  \n  // If namespace is completely empty, return {}\n  const hasFrontmatter = fm && Object.keys(fm).length > 0;\n  if (!hasFrontmatter && !hasExports) {\n    return '{}';\n  }\n  \n  // Remove empty frontmatter if no data\n  if (!hasFrontmatter) {\n    delete cleaned.frontmatter;\n  }\n  \n  // Pretty print the JSON with 2-space indentation\n  return JSON.stringify(cleaned, null, 2);\n}\n","import type { Environment } from '../env/Environment';\nimport type { EvalResult } from '../core/interpreter';\nimport type { MlldNode, BinaryExpression, TernaryExpression, UnaryExpression } from '@core/types';\nimport type { Variable } from '@core/types/variable';\nimport { evaluate } from '../core/interpreter';\nimport { \n  isTextLike, \n  isArray as isArrayVariable, \n  isObject as isObjectVariable, \n  isCommandResult, \n  isPipelineInput \n} from '@core/types/variable';\nimport { asText, assertStructuredValue, isStructuredValue } from '../utils/structured-value';\nimport { executeParallelExecInvocations } from './helpers/parallel-exec';\n\n/**\n * Determines if a value is truthy according to mlld rules\n * (copied from when.ts to avoid circular dependencies)\n */\nexport function isTruthy(value: any): boolean {\n  // Handle Variable types\n  if (value && typeof value === 'object' && 'type' in value && 'name' in value) {\n    const variable = value as Variable;\n    \n    // Type-specific truthiness for Variables\n    if (isTextLike(variable)) {\n      // Check for mlld falsy string values\n      const str = variable.value;\n      if (str === '' || str.toLowerCase() === 'false' || str === '0') {\n        return false;\n      }\n      return true;\n    } else if (isArrayVariable(variable)) {\n      return variable.value.length > 0;\n    } else if (isObjectVariable(variable)) {\n      return Object.keys(variable.value).length > 0;\n    } else if (isCommandResult(variable)) {\n      // Command results are truthy if they have output\n      return variable.value.trim().length > 0;\n    } else if (isPipelineInput(variable)) {\n      assertStructuredValue(variable.value, 'expression:isTruthy:pipeline-input');\n      return asText(variable.value).length > 0;\n    }\n    \n    // For other variable types, use their value\n    return isTruthy(variable.value);\n  }\n  \n  // Handle direct values\n  if (value === null || value === undefined) {\n    return false;\n  }\n  \n  if (typeof value === 'boolean') {\n    return value;\n  }\n  \n  if (typeof value === 'number') {\n    return value !== 0 && !isNaN(value);\n  }\n  \n  if (typeof value === 'string') {\n    // Wildcard is always true\n    if (value === '*') {\n      return true;\n    }\n    // Empty string is false\n    if (value === '') {\n      return false;\n    }\n    // String \"false\" is false (case insensitive)\n    if (value.toLowerCase() === 'false') {\n      return false;\n    }\n    // String \"0\" is false\n    if (value === '0') {\n      return false;\n    }\n    // All other strings are true\n    return true;\n  }\n  \n  if (Array.isArray(value)) {\n    return value.length > 0;\n  }\n  \n  if (typeof value === 'object') {\n    return Object.keys(value).length > 0;\n  }\n  \n  // Default to JavaScript truthiness\n  return !!value;\n}\n\n/**\n * Evaluate expression nodes (BinaryExpression, TernaryExpression, UnaryExpression)\n */\nexport async function evaluateExpression(\n  node: BinaryExpression | TernaryExpression | UnaryExpression,\n  env: Environment,\n  context?: { isExpression?: boolean }\n): Promise<EvalResult> {\n  \n  if (node.type === 'BinaryExpression') {\n    return evaluateBinaryExpression(node, env, context);\n  } else if (node.type === 'TernaryExpression') {\n    return evaluateTernaryExpression(node, env, context);\n  } else if (node.type === 'UnaryExpression') {\n    return evaluateUnaryExpression(node, env, context);\n  }\n  \n  throw new Error(`Unknown expression type: ${(node as any).type}`);\n}\n\n/**\n * Evaluate binary expressions (&&, ||, ==, !=, <, >, <=, >=)\n */\nasync function evaluateBinaryExpression(node: BinaryExpression, env: Environment, context?: { isExpression?: boolean }): Promise<EvalResult> {\n  let { operator, left, right } = node;\n  \n  // Handle operator being an array (from PEG.js negative lookahead)\n  if (Array.isArray(operator)) {\n    operator = operator[0];\n  }\n  \n  const isExecParallel =\n    operator === '||' &&\n    left?.type === 'ExecInvocation' &&\n    right?.type === 'ExecInvocation';\n  if (isExecParallel) {\n    const { value } = await executeParallelExecInvocations(left, right, env);\n    return { value, env };\n  }\n  \n  // Short-circuit evaluation for logical operators\n  const expressionContext = { isExpression: true, ...context };\n  \n  if (operator === '&&') {\n    const leftResult = await evaluate(left, env, expressionContext);\n    const leftTruthy = isTruthy(leftResult.value);\n    \n    // Short-circuit: if left is falsy, return left value\n    if (!leftTruthy) {\n      return { value: leftResult.value, env };\n    }\n    \n    // Otherwise evaluate and return right\n    const rightResult = await evaluate(right, env, expressionContext);\n    return { value: rightResult.value, env };\n  }\n  \n  if (operator === '||') {\n    const leftResult = await evaluate(left, env, expressionContext);\n    const leftTruthy = isTruthy(leftResult.value);\n    \n    \n    // Short-circuit: if left is truthy, return left value\n    if (leftTruthy) {\n      return { value: leftResult.value, env };\n    }\n    \n    // Otherwise evaluate and return right\n    const rightResult = await evaluate(right, env, expressionContext);\n    return { value: rightResult.value, env };\n  }\n  \n  // Comparison operators - evaluate both sides\n  const leftResult = await evaluate(left, env, expressionContext);\n  const rightResult = await evaluate(right, env, expressionContext);\n  \n  \n  if (operator === '==') {\n    const equal = isEqual(leftResult.value, rightResult.value);\n    return { value: equal, env };\n  }\n  \n  if (operator === '!=') {\n    const equal = isEqual(leftResult.value, rightResult.value);\n    return { value: !equal, env };\n  }\n  \n  // Numeric comparison operators\n  if (operator === '<') {\n    const leftNum = toNumber(leftResult.value);\n    const rightNum = toNumber(rightResult.value);\n    return { value: leftNum < rightNum, env };\n  }\n  \n  if (operator === '>') {\n    const leftNum = toNumber(leftResult.value);\n    const rightNum = toNumber(rightResult.value);\n    return { value: leftNum > rightNum, env };\n  }\n  \n  if (operator === '<=') {\n    const leftNum = toNumber(leftResult.value);\n    const rightNum = toNumber(rightResult.value);\n    return { value: leftNum <= rightNum, env };\n  }\n  \n  if (operator === '>=') {\n    const leftNum = toNumber(leftResult.value);\n    const rightNum = toNumber(rightResult.value);\n    return { value: leftNum >= rightNum, env };\n  }\n  \n  throw new Error(`Unknown binary operator: ${operator}`);\n}\n\n/**\n * Evaluate ternary expressions (condition ? trueBranch : falseBranch)\n */\nasync function evaluateTernaryExpression(node: TernaryExpression, env: Environment, context?: { isExpression?: boolean }): Promise<EvalResult> {\n  const { condition, trueBranch, falseBranch } = node;\n  \n  // Evaluate condition\n  const condResult = await evaluate(condition, env, { isExpression: true, ...context });\n  const condTruthy = isTruthy(condResult.value);\n  \n  // Evaluate and return appropriate branch\n  if (condTruthy) {\n    return evaluate(trueBranch, env, { isExpression: true, ...context });\n  } else {\n    return evaluate(falseBranch, env, { isExpression: true, ...context });\n  }\n}\n\n/**\n * Evaluate unary expressions (!)\n */\nasync function evaluateUnaryExpression(node: UnaryExpression, env: Environment, context?: { isExpression?: boolean }): Promise<EvalResult> {\n  const { operator, operand } = node;\n  \n  if (operator === '!') {\n    const operandResult = await evaluate(operand, env, { isExpression: true, ...context });\n    const operandTruthy = isTruthy(operandResult.value);\n    return { value: !operandTruthy, env };\n  }\n  \n  throw new Error(`Unknown unary operator: ${operator}`);\n}\n\n/**\n * mlld equality comparison\n * Follows mlld's type coercion rules:\n * - \"true\" == true\n * - \"false\" == false  \n * - null == undefined\n * - Numbers are compared numerically\n * - Strings are compared as strings\n */\nexport function isEqual(a: unknown, b: unknown): boolean {\n  // Extract Variable values\n  const aValue = extractValue(a);\n  const bValue = extractValue(b);\n  \n  // Handle null/undefined equality\n  if (aValue === null || aValue === undefined) {\n    return bValue === null || bValue === undefined;\n  }\n  if (bValue === null || bValue === undefined) {\n    return false;\n  }\n  \n  // Handle boolean string coercion\n  if (typeof aValue === 'string' && typeof bValue === 'boolean') {\n    return (aValue === 'true' && bValue === true) || (aValue === 'false' && bValue === false);\n  }\n  if (typeof bValue === 'string' && typeof aValue === 'boolean') {\n    return (bValue === 'true' && aValue === true) || (bValue === 'false' && aValue === false);\n  }\n  \n  // Handle numeric string comparison\n  if (typeof aValue === 'string' && typeof bValue === 'number') {\n    const numA = Number(aValue);\n    return !isNaN(numA) && numA === bValue;\n  }\n  if (typeof bValue === 'string' && typeof aValue === 'number') {\n    const numB = Number(bValue);\n    return !isNaN(numB) && numB === aValue;\n  }\n  \n  // Default to strict equality\n  return aValue === bValue;\n}\n\n/**\n * Extract the raw value from a Variable or return the value as-is\n */\nfunction extractValue(value: unknown): unknown {\n  if (value && typeof value === 'object' && 'type' in value && 'value' in value) {\n    const variable = value as Variable;\n    return extractValue(variable.value);\n  }\n  if (isStructuredValue(value)) {\n    return value.data ?? value.text;\n  }\n  return value;\n}\n\n/**\n * Convert a value to a number for numeric comparisons\n * Follows mlld's type coercion rules:\n * - Parse strings to numbers\n * - true → 1, false → 0\n * - null → 0, undefined → NaN\n * - Non-numeric strings → NaN\n */\nexport function toNumber(value: unknown): number {\n  // Use extractValue to handle both Variables and StructuredValues\n  const extracted = extractValue(value);\n\n  // Handle null and undefined\n  if (extracted === null) {\n    return 0;\n  }\n  if (extracted === undefined) {\n    return NaN;\n  }\n\n  // Handle booleans\n  if (typeof extracted === 'boolean') {\n    return extracted ? 1 : 0;\n  }\n\n  // Handle numbers\n  if (typeof extracted === 'number') {\n    return extracted;\n  }\n\n  // Handle strings\n  if (typeof extracted === 'string') {\n    // Special case for boolean strings\n    if (extracted === 'true') {\n      return 1;\n    }\n    if (extracted === 'false') {\n      return 0;\n    }\n    // Try to parse as number\n    const num = Number(extracted);\n    return num;\n  }\n\n  // For objects and arrays, return NaN\n  return NaN;\n}\n"]}