{"version":3,"sources":["../interpreter/eval/import/VariableImporter.ts"],"names":["VariableImporter","objectResolver","serializeShadowEnvs","envs","result","lang","shadowMap","Object","entries","Map","size","obj","name","func","deserializeShadowEnvs","shadowObj","map","set","ensureImportBindingAvailable","targetEnv","importSource","location","trim","length","existingBinding","getImportBinding","MlldImportError","source","code","context","existingSource","attemptedSource","existingLocation","newLocation","suggestion","details","filePath","variableName","setVariableWithImportBinding","alias","variable","binding","shouldPersistBinding","setVariable","setImportBinding","serializeModuleEnv","moduleEnv","tempResult","processModuleExports","undefined","moduleObject","deserializeModuleEnv","varData","createVariableFromValue","importVariables","processingResult","directive","serializedMetadata","extractMetadataMap","moduleObjectForImport","fromEntries","filter","key","handleImportType","childEnvironment","guardDefinitions","childVars","parseResult","skipModuleEnvSerialization","manifest","childEnv","options","currentSerializationTarget","frontmatter","serializedMetadataMap","manifestEntries","hasEntries","getEntries","variableEntries","entry","kind","guardEntries","explicitNames","explicitExports","Set","has","getLocation","exportName","guardNames","guards","definition","getGuardRegistry","getByName","guardName","shouldSerializeModuleEnv","moduleEnvSnapshot","getModuleEnvSnapshot","process","env","MLLD_DEBUG","console","log","Array","from","keys","join","envSnapshot","getSecuritySnapshot","envDescriptor","makeSecurityDescriptor","labels","taint","sources","policyContext","policy","isLegitimateVariableForExport","type","execVar","serializedInternal","internal","capturedShadowEnvs","capturedEnv","capturedModuleEnv","existingCapture","__executable","value","executableDef","templateVar","__template","content","templateSyntax","parameters","templateAst","isArray","resolvedObject","resolveObjectReferences","resolveStrings","descriptor","mx","varMxToSecurityDescriptor","mergedDescriptor","mergeDescriptors","metadataForSerialization","security","capability","VariableMetadataUtils","serializeSecurityMetadata","__metadata__","serializeGuardsByNames","importPath","originalName","syntax","hasInterpolation","isMultiLine","deserialized","deserializeSecurityMetadata","snapshot","snapshotDescriptor","combinedDescriptor","baseMetadata","isImported","definedAt","line","column","initialMetadata","applySecurityMetadata","securityLabels","existingDescriptor","buildMetadata","extra","isStructuredValue","createStructuredValueVariable","structuredValueType","createExecutableFromImport","templateSource","tmplMetadata","templateOptions","metadata","createTemplateVariable","originalType","inferVariableType","processedValue","isComplexArray","hasComplexContent","MLLD_DEBUG_FIX","error","sample","slice","createArrayVariable","normalizedObject","unwrapArraySnapshots","isComplex","agentRosterPreview","agent_roster","fs","appendFileSync","JSON","stringify","agentRosterType","agentRosterIsVariable","isVariableLike","agentRosterIsArray","createObjectVariable","createImportedVariable","item","__arraySnapshot","arrayMetadata","normalizedElements","arrayName","createNamespaceVariable","metadataMap","namespaceMetadata","namespaceOptions","isNamespace","container","subtype","handleNamespaceImport","registerSerializedGuards","handleSelectedImport","Error","namespaceNodes","values","namespace","imports","importerFilePath","getCurrentFilePath","aliasLocationNode","aliasLocation","astLocationToSourceLocation","namespaceObject","importDisplay","getImportDisplayPath","bindingInfo","recordPolicyConfig","meta","namespaceVar","policyConfig","config","importItem","importName","identifier","bindingLocation","importedValue","fallback","raw","path","trimmed","replace","paramNames","originalInternal","deserializedEnv","_","existingEnv","enhancedMetadata","finalMetadata","finalInternal","execVariable","createExecutableVariable","some","prop","isSystem"],"mappings":";;;;;;AAyCO,IAAMA,iBAAAA,GAAN,MAAMA,iBAAAA,CAAAA;AACX,EAAA,WAAA,CAAoBC,cAAyC,EAAA;;SAAzCA,cAAAA,GAAAA,cAAAA;AAA0C;;;;;;AAOtDC,EAAAA,mBAAAA,CAAoBC,IAAqC,EAAA;AAC/D,IAAA,MAAMC,SAAc,EAAC;AAErB,IAAA,KAAA,MAAW,CAACC,IAAMC,EAAAA,SAAAA,KAAcC,MAAOC,CAAAA,OAAAA,CAAQL,IAAAA,CAAO,EAAA;AACpD,MAAA,IAAIG,SAAqBG,YAAAA,GAAAA,IAAOH,SAAUI,CAAAA,IAAAA,GAAO,CAAG,EAAA;AAElD,QAAA,MAAMC,MAA2B,EAAC;AAClC,QAAA,KAAA,MAAW,CAACC,IAAAA,EAAMC,IAAAA,CAAAA,IAASP,SAAW,EAAA;AACpCK,UAAAA,GAAAA,CAAIC,IAAAA,CAAQC,GAAAA,IAAAA;AACd;AACAT,QAAAA,MAAAA,CAAOC,IAAAA,CAAQM,GAAAA,GAAAA;AACjB;AACF;AAEA,IAAOP,OAAAA,MAAAA;AACT;;;;;AAMQU,EAAAA,qBAAAA,CAAsBX,IAAqC,EAAA;AACjE,IAAA,MAAMC,SAAmC,EAAC;AAE1C,IAAA,KAAA,MAAW,CAACC,IAAMU,EAAAA,SAAAA,KAAcR,MAAOC,CAAAA,OAAAA,CAAQL,IAAAA,CAAO,EAAA;AACpD,MAAIY,IAAAA,SAAAA,IAAa,OAAOA,SAAAA,KAAc,QAAU,EAAA;AAE9C,QAAMC,MAAAA,GAAAA,uBAAUP,GAAAA,EAAAA;AAChB,QAAA,KAAA,MAAW,CAACG,IAAMC,EAAAA,IAAAA,KAASN,MAAOC,CAAAA,OAAAA,CAAQO,SAAAA,CAAY,EAAA;AACpDC,UAAIC,GAAAA,CAAAA,GAAAA,CAAIL,MAAMC,IAAAA,CAAAA;AAChB;AACAT,QAAAA,MAAAA,CAAOC,IAAAA,CAA0CW,GAAAA,GAAAA;AACnD;AACF;AAEA,IAAOZ,OAAAA,MAAAA;AACT;;;;;EAMQc,4BACNC,CAAAA,SAAAA,EACAP,IACAQ,EAAAA,YAAAA,EACAC,QACM,EAAA;AACN,IAAA,IAAI,CAACT,IAAQA,IAAAA,IAAAA,CAAKU,IAAI,EAAA,CAAGC,WAAW,CAAG,EAAA;AACvC,IAAMC,MAAAA,eAAAA,GAAkBL,SAAUM,CAAAA,gBAAAA,CAAiBb,IAAAA,CAAAA;AACnD,IAAA,IAAI,CAACY,eAAiB,EAAA;AACpB,MAAA;AACF;AAEA,IAAA,MAAM,IAAIE,eACR,CAAA,CAAA,oBAAA,EAAuBd,IAAAA,CAA+BY,wBAAAA,EAAAA,eAAAA,CAAgBG,MAAM,CAC5E,2BAAA,CAAA,EAAA;MACEC,IAAM,EAAA,sBAAA;MACNC,OAAS,EAAA;AACPjB,QAAAA,IAAAA;AACAkB,QAAAA,cAAAA,EAAgBN,eAAgBG,CAAAA,MAAAA;QAChCI,eAAiBX,EAAAA,YAAAA;AACjBY,QAAAA,gBAAAA,EAAkBR,eAAgBH,CAAAA,QAAAA;QAClCY,WAAaZ,EAAAA,QAAAA;QACba,UAAY,EAAA;AACd,OAAA;MACAC,OAAS,EAAA;QACPC,QAAUf,EAAAA,QAAAA,EAAUe,QAAYZ,IAAAA,eAAAA,CAAgBH,QAAUe,EAAAA,QAAAA;QAC1DC,YAAczB,EAAAA;AAChB;KACF,CAAA;AAEJ;;;;;;EAOQ0B,4BACNnB,CAAAA,SAAAA,EACAoB,KACAC,EAAAA,QAAAA,EACAC,OACM,EAAA;AACN,IAAA,IAAIC,oBAAuB,GAAA,KAAA;AAC3B,IAAI,IAAA;AACFvB,MAAUwB,SAAAA,CAAAA,WAAAA,CAAYJ,OAAOC,QAAAA,CAAAA;AAC7BE,MAAuB,oBAAA,GAAA,IAAA;KACzB,SAAA;AACE,MAAA,IAAIA,oBAAsB,EAAA;AACxBvB,QAAUyB,SAAAA,CAAAA,gBAAAA,CAAiBL,OAAOE,OAAAA,CAAAA;AACpC;AACF;AACF;;;;;;AAOQI,EAAAA,kBAAAA,CAAmBC,SAAuC,EAAA;AAIhE,IAAMC,MAAAA,UAAAA,GAAa,IAAKC,CAAAA,oBAAAA,CAAqBF,SAAW,EAAA,IAAI,IAAM,EAAA,IAAA,EAAMG,MAAWA,EAAAA,MAAAA,EAAWH,SAAAA,CAAAA;AAC9F,IAAA,OAAOC,UAAWG,CAAAA,YAAAA;AACpB;;;;;AAMAC,EAAAA,oBAAAA,CAAqBL,SAAuC,EAAA;AAC1D,IAAM1C,MAAAA,MAAAA,uBAAaK,GAAAA,EAAAA;AACnB,IAAIqC,IAAAA,SAAAA,IAAa,OAAOA,SAAAA,KAAc,QAAU,EAAA;AAC9C,MAAA,KAAA,MAAW,CAAClC,IAAMwC,EAAAA,OAAAA,KAAY7C,MAAOC,CAAAA,OAAAA,CAAQsC,SAAAA,CAAY,EAAA;AAEvD,QAAA,MAAMN,WAAW,IAAKa,CAAAA,uBAAAA,CACpBzC,IACAwC,EAAAA,OAAAA,EACA,cACAxC,IAAAA,CAAAA;AAEFR,QAAOa,MAAAA,CAAAA,GAAAA,CAAIL,MAAM4B,QAAAA,CAAAA;AACnB;AACF;AACA,IAAOpC,OAAAA,MAAAA;AACT;;;;EAKA,MAAMkD,eAAAA,CACJC,gBACAC,EAAAA,SAAAA,EACArC,SACe,EAAA;AACf,IAAM,MAAA,EAAE+B,cAAiBK,GAAAA,gBAAAA;AACzB,IAAME,MAAAA,kBAAAA,GAAqB,IAAKC,CAAAA,kBAAAA,CAAmBR,YAAAA,CAAAA;AACnD,IAAA,MAAMS,wBAAwBF,kBAC1BlD,GAAAA,MAAAA,CAAOqD,WAAYrD,CAAAA,MAAAA,CAAOC,QAAQ0C,YAAAA,CAAAA,CAAcW,MAAO,CAAA,CAAC,CAACC,GAAAA,CAAAA,KAASA,GAAQ,KAAA,cAAA,CAAA,CAC1EZ,GAAAA,YAAAA;AAGJ,IAAM,MAAA,IAAA,CAAKa,iBACTP,SACAG,EAAAA,qBAAAA,EACAxC,WACAoC,gBAAiBS,CAAAA,gBAAAA,EACjBP,kBACAF,EAAAA,gBAAAA,CAAiBU,gBAAgB,CAAA;AAErC;;;;AAKAjB,EAAAA,oBAAAA,CACEkB,WACAC,WACAC,EAAAA,0BAAAA,EACAC,QACAC,EAAAA,QAAAA,EACAC,SACAC,0BACqH,EAAA;AAErH,IAAMC,MAAAA,WAAAA,GAAcN,YAAYM,WAAe,IAAA,IAAA;AAG/C,IAAA,MAAMvB,eAAoC,EAAC;AAC3C,IAAA,MAAMwB,wBAA4G,EAAC;AACnH,IAAA,MAAMC,kBAAkBN,QAAUO,EAAAA,UAAAA,KAAeP,QAASQ,CAAAA,UAAAA,KAAe,EAAA;AACzE,IAAA,MAAMC,kBAAkBH,eAAgBd,CAAAA,MAAAA,CAAOkB,CAAAA,KAASA,KAAAA,KAAAA,CAAMC,SAAS,OAAA,CAAA;AACvE,IAAA,MAAMC,eAAeN,eAAgBd,CAAAA,MAAAA,CAAOkB,CAAAA,KAASA,KAAAA,KAAAA,CAAMC,SAAS,OAAA,CAAA;AACpE,IAAME,MAAAA,aAAAA,GAAgBJ,eAAgBvD,CAAAA,MAAAA,GAAS,CAAIuD,GAAAA,eAAAA,CAAgB9D,IAAI+D,CAAAA,KAAAA,KAASA,KAAMnE,CAAAA,IAAI,CAAI,GAAA,IAAA;AAC9F,IAAA,MAAMuE,eAAkBD,GAAAA,aAAAA,GAAgB,IAAIE,GAAAA,CAAIF,aAAAA,CAAiB,GAAA,IAAA;AACjE,IAAIA,IAAAA,aAAAA,IAAiBA,aAAc3D,CAAAA,MAAAA,GAAS,CAAG,EAAA;AAC7C,MAAA,KAAA,MAAWX,QAAQsE,aAAe,EAAA;AAChC,QAAA,IAAI,CAAChB,SAAAA,CAAUmB,GAAIzE,CAAAA,IAAAA,CAAO,EAAA;AACxB,UAAMS,MAAAA,QAAAA,GAAWgD,QAAUiB,EAAAA,WAAAA,CAAY1E,IAAAA,CAAAA;AACvC,UAAA,MAAM,IAAIc,eAAAA,CACR,CAAkBd,eAAAA,EAAAA,IAAAA,CAClB,+BAAA,CAAA,EAAA;YACEgB,IAAM,EAAA,yBAAA;YACNC,OAAS,EAAA;cACP0D,UAAY3E,EAAAA,IAAAA;AACZS,cAAAA;AACF,aAAA;YACAc,OAAS,EAAA;AACPC,cAAAA,QAAAA,EAAUf,QAAUe,EAAAA,QAAAA;cACpBC,YAAczB,EAAAA;AAChB;WACF,CAAA;AAEJ;AACF;AACF;AAEA,IAAA,MAAM4E,aAAaP,YAAajE,CAAAA,GAAAA,CAAI+D,CAAAA,KAAAA,KAASA,MAAMnE,IAAI,CAAA;AACvD,IAAI4E,IAAAA,UAAAA,CAAWjE,SAAS,CAAG,EAAA;AACzB,MAAA,IAAI,CAAC+C,QAAU,EAAA;AACb,QAAM,MAAA,IAAI5C,gBAAgB,2CAA6C,EAAA;UACrEE,IAAM,EAAA,sBAAA;UACNO,OAAS,EAAA;YAAEsD,MAAQD,EAAAA;AAAW;SAChC,CAAA;AACF;AACA,MAAA,KAAA,MAAWT,SAASE,YAAc,EAAA;AAChC,QAAA,MAAMS,aAAapB,QAASqB,CAAAA,gBAAAA,EAAmBC,CAAAA,SAAAA,CAAUb,MAAMnE,IAAI,CAAA;AACnE,QAAA,IAAI,CAAC8E,UAAY,EAAA;AACf,UAAA,MAAMrE,QAAWgD,GAAAA,QAAAA,EAAUiB,WAAYP,CAAAA,KAAAA,CAAMnE,IAAI,CAAA;AACjD,UAAA,MAAM,IAAIc,eAAAA,CAAgB,CAAmBqD,gBAAAA,EAAAA,KAAAA,CAAMnE,IAAI,CAAmC,+BAAA,CAAA,EAAA;YACxFgB,IAAM,EAAA,0BAAA;YACNC,OAAS,EAAA;AACPgE,cAAAA,SAAAA,EAAWd,KAAMnE,CAAAA,IAAAA;AACjBS,cAAAA;AACF,aAAA;YACAc,OAAS,EAAA;AACPC,cAAAA,QAAAA,EAAUf,QAAUe,EAAAA,QAAAA;AACpBC,cAAAA,YAAAA,EAAc0C,KAAMnE,CAAAA;AACtB;WACF,CAAA;AACF;AACF;AACF;AAEA,IAAA,MAAMkF,2BAA2B,CAAC1B,0BAAAA;AAClC,IAAA,IAAI2B,iBAAkD,GAAA,IAAA;AACtD,IAAA,MAAMC,uCAAuB,MAAA,CAAA,MAAA;AAC3B,MAAA,IAAI,CAACD,iBAAmB,EAAA;AACtBA,QAAoB,iBAAA,GAAA,IAAItF,IAAIyD,SAAAA,CAAAA;AAC9B;AACA,MAAO6B,OAAAA,iBAAAA;KAJoB,EAAA,sBAAA,CAAA;AAQ7B,IAAIE,IAAAA,OAAAA,CAAQC,GAAIC,CAAAA,UAAAA,KAAe,MAAQ,EAAA;AACrCC,MAAAA,OAAAA,CAAQC,GAAI,CAAA,CAAA,uCAAA,EAA0CnC,SAAUxD,CAAAA,IAAI,CAAE,CAAA,CAAA;AACtE0F,MAAQC,OAAAA,CAAAA,GAAAA,CAAI,CAA0CC,uCAAAA,EAAAA,KAAAA,CAAMC,IAAKrC,CAAAA,SAAAA,CAAUsC,IAAI,EAAA,CAAIC,CAAAA,IAAAA,CAAK,IAAA,CAAA,CAAO,CAAA,CAAA;AACjG;AAEA,IAAMC,MAAAA,WAAAA,GAAcpC,UAAUqC,mBAAAA,IAAAA;AAC9B,IAAMC,MAAAA,aAAAA,GAAgBF,cAClBG,sBAAuB,CAAA;AACrBC,MAAAA,MAAAA,EAAQJ,WAAYI,CAAAA,MAAAA;AACpBC,MAAAA,KAAAA,EAAOL,WAAYK,CAAAA,KAAAA;AACnBC,MAAAA,OAAAA,EAASN,WAAYM,CAAAA,OAAAA;AACrBC,MAAAA,aAAAA,EAAeP,YAAYQ,MAAS,GAAA;AAAE,QAAA,GAAGR,WAAYQ,CAAAA;OAAWjE,GAAAA;AAClE,KAAA,CACAA,GAAAA,MAAAA;AAEJ,IAAA,KAAA,MAAW,CAACrC,IAAAA,EAAM4B,QAAAA,CAAAA,IAAa0B,SAAW,EAAA;AACxC,MAAA,IAAIiB,eAAmB,IAAA,CAACA,eAAgBE,CAAAA,GAAAA,CAAIzE,IAAAA,CAAO,EAAA;AACjD,QAAA;AACF;AAGA,MAAA,IAAI,CAAC,IAAA,CAAKuG,6BAA8B3E,CAAAA,QAAAA,CAAW,EAAA;AACjD,QAAIyD,IAAAA,OAAAA,CAAQC,GAAIC,CAAAA,UAAAA,KAAe,MAAQ,EAAA;AACrCC,UAAAA,OAAAA,CAAQC,IAAI,CAA4DzF,yDAAAA,EAAAA,IAAAA,CAAoB4B,aAAAA,EAAAA,QAAAA,CAAS4E,IAAI,CAAE,CAAA,CAAA;AAC7G;AACA,QAAA;AACF;AAEA,MAAI5E,IAAAA,QAAAA,CAAS4E,SAAS,YAAc,EAAA;AAClC,QAAA,MAAMC,OAAU7E,GAAAA,QAAAA;AAGhB,QAAA,IAAI8E,kBAA8C,GAAA;UAAE,GAAID,OAAAA,CAAQE,YAAY;AAAI,SAAA;AAChF,QAAA,IAAID,mBAAmBE,kBAAoB,EAAA;AACzCF,UAAqB,kBAAA,GAAA;YACnB,GAAGA,kBAAAA;YACHE,kBAAoB,EAAA,IAAA,CAAKtH,mBAAoBoH,CAAAA,kBAAAA,CAAmBE,kBAAkB;AACpF,WAAA;AACF;AACA,QAAA,IAAI1B,wBAA0B,EAAA;AAC5B,UAAA,MAAM2B,cACJH,kBAAmBI,CAAAA,iBAAAA,YAA6BjH,GAC5C6G,GAAAA,kBAAAA,CAAmBI,oBACnB1B,oBAAAA,EAAAA;AACNsB,UAAqB,kBAAA,GAAA;YACnB,GAAGA,kBAAAA;YACHI,iBAAmB,EAAA,IAAA,CAAK7E,mBAAmB4E,WAAAA;AAC7C,WAAA;SACK,MAAA;AAWL,UAAA,MAAME,kBAAkBL,kBAAmBI,CAAAA,iBAAAA;AAC3C,UAAA,IAAIC,2BAA2BlH,GAAK,EAAA;AAElC,YAAI+D,IAAAA,0BAAAA,IAA8BmD,oBAAoBnD,0BAA4B,EAAA;AAEhF,cAAA,OAAO8C,kBAAmBI,CAAAA,iBAAAA;aACrB,MAAA;AAELJ,cAAqB,kBAAA,GAAA;gBACnB,GAAGA,kBAAAA;gBACHI,iBAAmB,EAAA,IAAA,CAAK7E,mBAAmB8E,eAAAA;AAC7C,eAAA;AACF;AACF;AAGF;AAGAzE,QAAAA,YAAAA,CAAatC,IAAAA,CAAQ,GAAA;UACnBgH,YAAc,EAAA,IAAA;AACdC,UAAAA,KAAAA,EAAOR,OAAQQ,CAAAA,KAAAA;;AAEfC,UAAAA,aAAAA,EAAeT,QAAQE,QAAUO,EAAAA,aAAAA;UACjCP,QAAUD,EAAAA;AACZ,SAAA;OACS9E,MAAAA,IAAAA,QAAAA,CAAS4E,SAAS,UAAY,EAAA;AACvC,QAAA,MAAMW,WAAcvF,GAAAA,QAAAA;AAEpBU,QAAAA,YAAAA,CAAatC,IAAAA,CAAQ,GAAA;UACnBoH,UAAY,EAAA,IAAA;AACZC,UAAAA,OAAAA,EAASF,WAAYF,CAAAA,KAAAA;AACrBK,UAAAA,cAAAA,EAAgBH,WAAYG,CAAAA,cAAAA;AAC5BC,UAAAA,UAAAA,EAAYJ,WAAYI,CAAAA,UAAAA;UACxBC,WAAaL,EAAAA,WAAAA,CAAYR,UAAUa,WAAgB9B,KAAAA,KAAAA,CAAM+B,QAAQN,WAAYF,CAAAA,KAAK,CAAIE,GAAAA,WAAAA,CAAYF,KAAQ5E,GAAAA,MAAAA;AAC5G,SAAA;OACST,MAAAA,IAAAA,QAAAA,CAAS4E,SAAS,QAAY,IAAA,OAAO5E,SAASqF,KAAU,KAAA,QAAA,IAAYrF,QAASqF,CAAAA,KAAAA,KAAU,IAAM,EAAA;AAEtG,QAAA,MAAMS,iBAAiB,IAAKrI,CAAAA,cAAAA,CAAesI,uBACzC/F,CAAAA,QAAAA,CAASqF,OACT3D,SACA,EAAA;AAAEsE,UAAAA,cAAAA,EAAgBjE,OAASiE,EAAAA;SAAe,CAAA;AAE5CtF,QAAAA,YAAAA,CAAatC,IAAAA,CAAQ0H,GAAAA,cAAAA;OAChB,MAAA;AAELpF,QAAatC,YAAAA,CAAAA,IAAAA,IAAQ4B,QAASqF,CAAAA,KAAAA;AAChC;AAEA,MAAA,MAAMY,aAAajG,QAASkG,CAAAA,EAAAA,GAAKC,yBAA0BnG,CAAAA,QAAAA,CAASkG,EAAE,CAAIzF,GAAAA,MAAAA;AAC1E,MAAA,MAAM2F,mBAAmBH,UAAc7B,IAAAA,aAAAA,GACnCiC,iBAAiBJ,UAAY7B,EAAAA,aAAAA,IAC7B6B,UAAc7B,IAAAA,aAAAA;AAClB,MAAA,MAAMkC,2BAA6C,EAAC;AACpD,MAAA,IAAIF,gBAAkB,EAAA;AACpBE,QAAAA,wBAAAA,CAAyBC,QAAWH,GAAAA,gBAAAA;AACtC;AACA,MAAIpG,IAAAA,QAAAA,CAAS+E,UAAUyB,UAAY,EAAA;AACjCF,QAAyBE,wBAAAA,CAAAA,UAAAA,GAAaxG,SAAS+E,QAASyB,CAAAA,UAAAA;AAC1D;AACA,MAAMvF,MAAAA,kBAAAA,GAAqBwF,qBAAsBC,CAAAA,yBAAAA,CAA0BJ,wBAAAA,CAAAA;AAC3E,MAAA,IAAIrF,kBAAoB,EAAA;AACtBiB,QAAAA,qBAAAA,CAAsB9D,IAAAA,CAAQ6C,GAAAA,kBAAAA;AAChC;AACF;AACA,IAAA,IAAIlD,MAAOiG,CAAAA,IAAAA,CAAK9B,qBAAAA,CAAAA,CAAuBnD,SAAS,CAAG,EAAA;AACjD2B,MAAAA,YAAAA,CAAaiG,YAAezE,GAAAA,qBAAAA;AAC9B;AAEA,IAAMe,MAAAA,MAAAA,GACJD,WAAWjE,MAAS,GAAA,CAAA,IAAK+C,WACrBA,QAAS8E,CAAAA,sBAAAA,CAAuB5D,UAAAA,CAAAA,GAChC,EAAA;AAEN,IAAO,OAAA;AACLtC,MAAAA,YAAAA;AACAuB,MAAAA,WAAAA;AACAgB,MAAAA;AACF,KAAA;AACF;;;;AAKApC,EAAAA,uBAAAA,CACEzC,IACAiH,EAAAA,KAAAA,EACAwB,UACAC,EAAAA,YAAAA,EACA/E,OAKU,EAAA;AACV,IAAA,MAAM5C,MAAyB,GAAA;MAC7B6B,SAAW,EAAA,KAAA;MACX+F,MAAQjD,EAAAA,KAAAA,CAAM+B,QAAQR,KAAAA,CAAAA,GAAS,UACtBA,KAAS,IAAA,OAAOA,KAAU,KAAA,QAAA,GAAY,QAAW,GAAA,QAAA;MAC1D2B,gBAAkB,EAAA,KAAA;MAClBC,WAAa,EAAA;AACf,KAAA;AACA,IAAA,MAAMC,YAAeT,GAAAA,qBAAAA,CAAsBU,2BAA4BpF,CAAAA,OAAAA,EAASd,kBAAAA,CAAAA;AAChF,IAAMmG,MAAAA,QAAAA,GAAWrF,OAAS2B,EAAAA,GAAAA,EAAKS,mBAAAA,IAAAA;AAC/B,IAAIkD,IAAAA,kBAAAA,GAAqBD,WACrB/C,sBAAuB,CAAA;AACrBC,MAAAA,MAAAA,EAAQ8C,QAAS9C,CAAAA,MAAAA;AACjBC,MAAAA,KAAAA,EAAO6C,QAAS7C,CAAAA,KAAAA;AAChBC,MAAAA,OAAAA,EAAS4C,QAAS5C,CAAAA,OAAAA;AAClBC,MAAAA,aAAAA,EAAe2C,SAAS1C,MAAS,GAAA;AAAE,QAAA,GAAG0C,QAAS1C,CAAAA;OAAWjE,GAAAA;AAC5D,KAAA,CACAA,GAAAA,MAAAA;AACJ,IAAA,IAAI6G,qBAAqBJ,YAAaX,CAAAA,QAAAA;AACtC,IAAA,IAAIc,kBAAoB,EAAA;AACtBC,MAAAA,kBAAAA,GAAqBA,kBACjBjB,GAAAA,gBAAAA,CAAiBiB,kBAAoBD,EAAAA,kBAAAA,CACrCA,GAAAA,kBAAAA;AACN;AACA,IAAA,MAAME,YAAe,GAAA;MACnBC,UAAY,EAAA,IAAA;AACZX,MAAAA,UAAAA;MACAC,YAAcA,EAAAA,YAAAA,KAAiB1I,OAAO0I,YAAerG,GAAAA,MAAAA;MACrDgH,SAAW,EAAA;QAAEC,IAAM,EAAA,CAAA;QAAGC,MAAQ,EAAA,CAAA;QAAG/H,QAAUiH,EAAAA;AAAW,OAAA;MACtD,GAAGK;AACL,KAAA;AACA,IAAMU,MAAAA,eAAAA,GAAkBnB,qBAAsBoB,CAAAA,qBAAAA,CAAsBN,YAAc,EAAA;AAChFjD,MAAAA,MAAAA,EAAQvC,OAAS+F,EAAAA,cAAAA;MACjBC,kBAAoBT,EAAAA;KACtB,CAAA;AACA,IAAA,MAAMU,aAAgB,mBAAA,MAAA,CAAA,CAACC,KACrBxB,KAAAA,qBAAAA,CAAsBoB,qBACpB,CAAA;MACE,GAAGD,eAAAA;AACH,MAAA,GAAIK,SAAS;KAEf,EAAA;AACE3D,MAAAA,MAAAA,EAAQvC,OAAS+F,EAAAA,cAAAA;AACjBC,MAAAA,kBAAAA,EAAoBH,eAAgBrB,CAAAA;AACtC,KAAA,CATkB,EAAA,eAAA,CAAA;AAYtB,IAAI2B,IAAAA,iBAAAA,CAAkB7C,KAAAA,CAAQ,EAAA;AAC5B,MAAA,OAAO8C,6BACL/J,CAAAA,IAAAA,EACAiH,KACAlG,EAAAA,MAAAA,EACA6I,aAAc,CAAA;QACZE,iBAAmB,EAAA,IAAA;AACnBE,QAAAA,mBAAAA,EAAqB/C,KAAMT,CAAAA;AAC7B,OAAA,CAAA,CAAA;AAEJ;AAGA,IAAA,IAAIS,SAAS,OAAOA,KAAAA,KAAU,YAAY,cAAkBA,IAAAA,KAAAA,IAASA,MAAMD,YAAc,EAAA;AACvF,MAAO,OAAA,IAAA,CAAKiD,2BAA2BjK,IAAMiH,EAAAA,KAAAA,EAAOlG,QAAQ6I,aAAAA,EAAAA,EAAiBjG,SAAS+F,cAAAA,CAAAA;AACxF;AAGA,IAAA,IAAIzC,KAAS,IAAA,OAAOA,KAAU,KAAA,QAAA,IAAaA,MAAcG,UAAY,EAAA;AACnE,MAAA,MAAM8C,cAAiC,GAAA;QACrCtH,SAAW,EAAA,KAAA;QACX+F,MAAQ,EAAA,UAAA;QACRC,gBAAkB,EAAA,IAAA;QAClBC,WAAa,EAAA;AACf,OAAA;AACA,MAAA,MAAMsB,eAAeP,aAAAA,EAAAA;AACrB,MAAA,MAAMQ,eAAkB,GAAA;QACtBC,QAAUF,EAAAA,YAAAA;QACVxD,QAAU,EAAA;AACRa,UAAAA,WAAAA,EAAcP,KAAcO,CAAAA;AAC9B;AACF,OAAA;AACA,MAAA,OAAO8C,sBACLtK,CAAAA,IAAAA,EACCiH,KAAcI,CAAAA,OAAAA,EACdJ,KAAcM,CAAAA,UAAAA,EACdN,KAAcK,CAAAA,cAAAA,KAAmB,aAAgB,GAAA,aAAA,GAAgB,aAClE4C,EAAAA,cAAAA,EACAE,eAAAA,CAAAA;AAEJ;AAGA,IAAMG,MAAAA,YAAAA,GAAe,IAAKC,CAAAA,iBAAAA,CAAkBvD,KAAAA,CAAAA;AAG5C,IAAA,IAAIwD,cAAiBxD,GAAAA,KAAAA;AAGrB,IAAA,IAAIsD,YAAiB,KAAA,OAAA,IAAW7E,KAAM+B,CAAAA,OAAAA,CAAQgD,cAAAA,CAAiB,EAAA;AAC7D,MAAMC,MAAAA,cAAAA,GAAiB,IAAKC,CAAAA,iBAAAA,CAAkBF,cAAAA,CAAAA;AAC9C,MAAIpF,IAAAA,OAAAA,CAAQC,GAAIsF,CAAAA,cAAAA,KAAmB,MAAQ,EAAA;AACzCpF,QAAAA,OAAAA,CAAQqF,MAAM,0CAA4C,EAAA;AACxD7K,UAAAA,IAAAA;AACAyI,UAAAA,UAAAA;AACAiC,UAAAA,cAAAA;UACAI,MAAQL,EAAAA,cAAAA,CAAeM,KAAM,CAAA,CAAA,EAAG,CAAA;SAClC,CAAA;AACF;AAEA,MAAA,OAAOC,mBACLhL,CAAAA,IAAAA,EACAyK,cACAC,EAAAA,cAAAA,EACA3J,QACA6I,aAAc,CAAA;QACZR,UAAY,EAAA,IAAA;AACZX,QAAAA,UAAAA;QACAC,YAAcA,EAAAA,YAAAA,KAAiB1I,OAAO0I,YAAerG,GAAAA;AACvD,OAAA,CAAA,CAAA;AAEJ;AAGA,IAAA,IAAIkI,iBAAiB,QAAU,EAAA;AAC7B,MAAA,MAAMU,gBAAmB,GAAA,IAAA,CAAKC,oBAAqBT,CAAAA,cAAAA,EAAgBhC,UAAAA,CAAAA;AAEnE,MAAM0C,MAAAA,SAAAA,GAAY,IAAKR,CAAAA,iBAAAA,CAAkBM,gBAAAA,CAAAA;AACzC,MAAI5F,IAAAA,OAAAA,CAAQC,GAAIsF,CAAAA,cAAAA,KAAmB,MAAQ,EAAA;AACzCpF,QAAAA,OAAAA,CAAQqF,MAAM,2CAA6C,EAAA;AACzD7K,UAAAA,IAAAA;AACAyI,UAAAA,UAAAA;AACA0C,UAAAA,SAAAA;UACAvF,IAAMjG,EAAAA,MAAAA,CAAOiG,KAAKqF,gBAAoB,IAAA,EAAC,CAAGF,CAAAA,KAAAA,CAAM,GAAG,CAAA,CAAA;AACnDK,UAAAA,kBAAAA,EAAoBH,oBAAqBA,gBAAyBI,CAAAA;SACpE,CAAA;AACA,QAAI,IAAA;AACFC,UAAGC,EAAAA,CAAAA,cAAAA,CACD,qBACAC,EAAAA,IAAAA,CAAKC,SAAU,CAAA;YACb1K,MAAQ,EAAA,kBAAA;AACRf,YAAAA,IAAAA;AACAyI,YAAAA,UAAAA;AACA0C,YAAAA,SAAAA;YACAvF,IAAMjG,EAAAA,MAAAA,CAAOiG,KAAKqF,gBAAoB,IAAA,EAAC,CAAGF,CAAAA,KAAAA,CAAM,GAAG,CAAA,CAAA;YACnDW,eAAiBT,EAAAA,gBAAAA,IAAoB,OAAQA,gBAAyBI,CAAAA,YAAAA;YACtEM,qBAAuB,EAAA,IAAA,CAAKC,cAAgBX,CAAAA,gBAAAA,CAAyBI,YAAY,CAAA;YACjFQ,kBAAoBnG,EAAAA,KAAAA,CAAM+B,OAASwD,CAAAA,gBAAAA,CAAyBI,YAAY;AAC1E,WAAA,IAAK,IAAA,CAAA;SAED,CAAA,MAAA;AAAC;AACX;AAEA,MAAA,OAAOS,oBACL9L,CAAAA,IAAAA,EACAiL,gBACAE,EAAAA,SAAAA,EACApK,QACA6I,aAAc,CAAA;QACZR,UAAY,EAAA,IAAA;AACZX,QAAAA,UAAAA;QACAC,YAAcA,EAAAA,YAAAA,KAAiB1I,OAAO0I,YAAerG,GAAAA;AACvD,OAAA,CAAA,CAAA;AAEJ;AAGA,IAAO0J,OAAAA,sBAAAA,CACL/L,IACAyK,EAAAA,cAAAA,EACAF,YACA9B,EAAAA,UAAAA,EACA,OACAC,YAAgB1I,IAAAA,IAAAA,EAChBe,MACA6I,EAAAA,aAAAA,EAAAA,CAAAA;AAEJ;AAEQsB,EAAAA,oBAAAA,CAAqBjE,OAAYwB,UAAyB,EAAA;AAChE,IAAI/C,IAAAA,KAAAA,CAAM+B,OAAQR,CAAAA,KAAAA,CAAQ,EAAA;AACxB,MAAOA,OAAAA,KAAAA,CAAM7G,IAAI4L,CAAAA,IAAAA,KAAQ,KAAKd,oBAAqBc,CAAAA,IAAAA,EAAMvD,UAAAA,CAAAA,CAAAA;AAC3D;AAEA,IAAIxB,IAAAA,KAAAA,IAAS,OAAOA,KAAAA,KAAU,QAAU,EAAA;AACtC,MAAA,IAAKA,MAAcgF,eAAiB,EAAA;AAClC,QAAA,MAAMjD,QAAW/B,GAAAA,KAAAA;AACjB,QAAA,MAAMlG,MAAyB,GAAA;UAC7B6B,SAAW,EAAA,KAAA;UACX+F,MAAQ,EAAA,OAAA;UACRC,gBAAkB,EAAA,KAAA;UAClBC,WAAa,EAAA;AACf,SAAA;AACA,QAAA,MAAMqD,aAAgB,GAAA;UACpB,GAAIlD,QAAAA,CAASqB,YAAY,EAAC;UAC1BjB,UAAY,EAAA,IAAA;AACZX,UAAAA,UAAAA;AACAC,UAAAA,YAAAA,EAAcM,QAAShJ,CAAAA;AACzB,SAAA;AACA,QAAA,MAAMmM,qBAAqBzG,KAAM+B,CAAAA,OAAAA,CAAQuB,QAAS/B,CAAAA,KAAK,IACnD+B,QAAS/B,CAAAA,KAAAA,CAAM7G,GAAI4L,CAAAA,CAAAA,SAAQ,IAAKd,CAAAA,oBAAAA,CAAqBc,MAAMvD,UAAAA,CAAAA,IAC3D,EAAA;AACJ,QAAM2D,MAAAA,SAAAA,GAAYpD,SAAShJ,IAAQ,IAAA,gBAAA;AACnC,QAAA,OAAOgL,oBAAoBoB,SAAWD,EAAAA,kBAAAA,EAAoBnD,SAASmC,SAAc,KAAA,IAAA,EAAMpK,QAAQmL,aAAAA,CAAAA;AACjG;AAIA,MAAA,IAAKjF,MAAcD,YAAc,EAAA;AAC/B,QAAA,MAAMjG,MAAyB,GAAA;UAC7B6B,SAAW,EAAA,KAAA;UACX+F,MAAQ,EAAA,QAAA;UACRC,gBAAkB,EAAA,KAAA;UAClBC,WAAa,EAAA;AACf,SAAA;AACA,QAAA,OAAO,IAAKoB,CAAAA,0BAAAA,CACV,UACAhD,EAAAA,KAAAA,EACAlG,MACA,EAAA;UAAEqI,UAAY,EAAA,IAAA;AAAMX,UAAAA;SAAW,CAAA;AAEnC;AAEA,MAAA,MAAMjJ,SAA8B,EAAC;AACrC,MAAA,KAAA,MAAW,CAAC0D,GAAKiB,EAAAA,KAAAA,KAAUxE,MAAOC,CAAAA,OAAAA,CAAQqH,KAAAA,CAAQ,EAAA;AAChDzH,QAAAA,MAAAA,CAAO0D,GAAAA,CAAAA,GAAO,IAAKgI,CAAAA,oBAAAA,CAAqB/G,OAAOsE,UAAAA,CAAAA;AACjD;AACA,MAAOjJ,OAAAA,MAAAA;AACT;AAEA,IAAOyH,OAAAA,KAAAA;AACT;;;;AAKAoF,EAAAA,uBAAAA,CACE1K,KACAW,EAAAA,YAAAA,EACAmG,UACAiB,EAAAA,cAAAA,EACA4C,aACAhH,GACU,EAAA;AACV,IAAA,MAAMvE,MAAyB,GAAA;MAC7B6B,SAAW,EAAA,KAAA;MACX+F,MAAQ,EAAA,QAAA;MACRC,gBAAkB,EAAA,KAAA;MAClBC,WAAa,EAAA;AACf,KAAA;AAGA,IAAMsC,MAAAA,SAAAA,GAAY,IAAKR,CAAAA,iBAAAA,CAAkBrI,YAAAA,CAAAA;AAEzC,IAAM0G,MAAAA,QAAAA,GAAW1D,KAAKS,mBAAAA,IAAAA;AACtB,IAAIkD,IAAAA,kBAAAA,GAAqBD,WACrB/C,sBAAuB,CAAA;AACrBC,MAAAA,MAAAA,EAAQ8C,QAAS9C,CAAAA,MAAAA;AACjBC,MAAAA,KAAAA,EAAO6C,QAAS7C,CAAAA,KAAAA;AAChBC,MAAAA,OAAAA,EAAS4C,QAAS5C,CAAAA,OAAAA;AAClBC,MAAAA,aAAAA,EAAe2C,SAAS1C,MAAS,GAAA;AAAE,QAAA,GAAG0C,QAAS1C,CAAAA;OAAWjE,GAAAA;AAC5D,KAAA,CACAA,GAAAA,MAAAA;AAEJ,IAAMgI,MAAAA,QAAAA,GAAWhC,sBAAsBoB,qBACrC,CAAA;MACEL,UAAY,EAAA,IAAA;AACZX,MAAAA,UAAAA;MACAY,SAAW,EAAA;QAAEC,IAAM,EAAA,CAAA;QAAGC,MAAQ,EAAA,CAAA;QAAG/H,QAAUiH,EAAAA;AAAW,OAAA;MACtD8D,iBAAmBD,EAAAA;KAErB,EAAA;MACEpG,MAAQwD,EAAAA,cAAAA;MACRC,kBAAoBV,EAAAA;KACtB,CAAA;AAEF,IAAA,MAAMuD,gBAAmB,GAAA;AACvBnC,MAAAA,QAAAA;MACA1D,QAAU,EAAA;QAAE8F,WAAa,EAAA;AAAK;AAChC,KAAA;AAEA,IAAA,OAAOX,oBACLnK,CAAAA,KAAAA,EACAW,YACA6I,EAAAA,SAAAA,EACApK,QACAyL,gBAAAA,CAAAA;AAEJ;AAEQ1J,EAAAA,kBAAAA,CACNR,YAC4G,EAAA;AAC5G,IAAA,MAAMoK,YAAapK,YAAqCiG,CAAAA,YAAAA;AACxD,IAAA,IAAI,CAACmE,SAAAA,IAAa,OAAOA,SAAAA,KAAc,QAAU,EAAA;AAC/C,MAAOrK,OAAAA,MAAAA;AACT;AAEA,IAAA,MAAM7C,SAAyG,EAAC;AAChH,IAAA,KAAA,MAAW,CAAC0D,GAAK+D,EAAAA,KAAAA,KAAUtH,MAAOC,CAAAA,OAAAA,CAAQ8M,SAAAA,CAAY,EAAA;AACpDlN,MAAAA,MAAAA,CAAO0D,GAAAA,CAAO+D,GAAAA,KAAAA;AAChB;AACA,IAAOzH,OAAAA,MAAAA;AACT;;;;AAKA,EAAA,MAAc2D,iBACZP,SACAN,EAAAA,YAAAA,EACA/B,SACAmD,EAAAA,QAAAA,EACA4I,aACAjJ,gBACe,EAAA;AACf,IAAIT,IAAAA,SAAAA,CAAU+J,YAAY,cAAgB,EAAA;AACxC,MAAA,MAAM,KAAKC,qBACThK,CAAAA,SAAAA,EACAN,cACA/B,SACAmD,EAAAA,QAAAA,EACA4I,aACAjJ,gBAAAA,CAAAA;KAEOT,MAAAA,IAAAA,SAAAA,CAAU+J,YAAY,WAAa,EAAA;AAC5C,MAAA,MAAM,IAAI7L,eAAAA,CACR,CAEA8B,sIAAAA,CAAAA,EAAAA,SAAAA,CAAUnC,QACV,EAAA;QACEa,UAAY,EAAA,CAAA,sDAAA;OACd,CAAA;KAEOsB,MAAAA,IAAAA,SAAAA,CAAU+J,YAAY,iBAAmB,EAAA;AAClD,MAAA,MAAM,KAAKC,qBACThK,CAAAA,SAAAA,EACAN,cACA/B,SACAmD,EAAAA,QAAAA,EACA4I,aACAjJ,gBAAAA,CAAAA;KAEOT,MAAAA,IAAAA,SAAAA,CAAU+J,YAAY,gBAAkB,EAAA;AACjD,MAAItJ,IAAAA,gBAAAA,IAAoBA,gBAAiB1C,CAAAA,MAAAA,GAAS,CAAG,EAAA;AACnDJ,QAAAA,SAAAA,CAAUsM,yBAAyBxJ,gBAAAA,CAAAA;AACrC;AACA,MAAA,MAAM,KAAKyJ,oBAAqBlK,CAAAA,SAAAA,EAAWN,YAAc/B,EAAAA,SAAAA,EAAWmD,UAAU4I,WAAAA,CAAAA;KACzE,MAAA;AACL,MAAA,MAAM,IAAIS,KAAAA,CAAM,CAA2BnK,wBAAAA,EAAAA,SAAAA,CAAU+J,OAAO,CAAE,CAAA,CAAA;AAChE;AACF;;;;AAKA,EAAA,MAAcC,sBACZhK,SACAN,EAAAA,YAAAA,EACA/B,SACAmD,EAAAA,QAAAA,EACA4I,aACAjJ,gBACe,EAAA;AAEf,IAAM2J,MAAAA,cAAAA,GAAiBpK,UAAUqK,MAAQC,EAAAA,SAAAA;AACzC,IAAA,MAAMvL,QAASqL,cAAkBtH,IAAAA,KAAAA,CAAM+B,QAAQuF,cAAAA,CAAAA,IAAmBA,eAAe,CAAA,CAAA,EAAI3F,OACjF2F,GAAAA,cAAAA,CAAe,CAAA,CAAG3F,CAAAA,OAAAA,GAClBzE,UAAUqK,MAAQE,EAAAA,OAAAA,GAAU,CAAA,CAAIxL,EAAAA,KAAAA;AAEpC,IAAA,IAAI,CAACA,KAAO,EAAA;AACV,MAAM,MAAA,IAAIoL,MAAM,gCAAA,CAAA;AAClB;AAEA,IAAMK,MAAAA,gBAAAA,GAAmB7M,UAAU8M,kBAAkB,EAAA;AACrD,IAAMC,MAAAA,iBAAAA,GAAoBN,kBAAkBtH,KAAM+B,CAAAA,OAAAA,CAAQuF,cAAAA,CAAkBA,GAAAA,cAAAA,CAAe,CAAA,CAAK3K,GAAAA,MAAAA;AAChG,IAAMkL,MAAAA,aAAAA,GAAgBD,iBAAmB7M,EAAAA,QAAAA,GACrC+M,2BAA4BF,CAAAA,iBAAAA,CAAkB7M,QAAU2M,EAAAA,gBAAAA,CACxDI,GAAAA,2BAAAA,CAA4B5K,SAAUnC,CAAAA,QAAAA,EAAU2M,gBAAAA,CAAAA;AAGpD,IAAA,MAAMK,eAAkBnL,GAAAA,YAAAA;AAExB,IAAMmG,MAAAA,UAAAA,GAAa/E,QAAS2J,CAAAA,kBAAAA,EAAwB,IAAA,SAAA;AACpD,IAAA,MAAMK,aAAgB,GAAA,IAAA,CAAKC,oBAAqB/K,CAAAA,SAAAA,EAAW6F,UAAAA,CAAAA;AAC3D,IAAA,MAAMmF,WAAc,GAAA;MAAE7M,MAAQ2M,EAAAA,aAAAA;MAAejN,QAAU8M,EAAAA;AAAc,KAAA;AAErE,IAAA,IAAA,CAAKjN,4BAA6BC,CAAAA,SAAAA,EAAWoB,KAAO+L,EAAAA,aAAAA,EAAeH,aAAAA,CAAAA;AAGnE,IAAA,IAAIE,eAAmB,IAAA,OAAOA,eAAoB,KAAA,QAAA,IAAaA,gBAAwBrG,UAAY,EAAA;AACjG,MAAA,MAAMD,cAAc,IAAK1E,CAAAA,uBAAAA,CAAwBd,KAAO8L,EAAAA,eAAAA,EAAiBhF,YAAYpG,MAAW,EAAA;QAC9FiD,GAAK/E,EAAAA;OACP,CAAA;AACA,MAAA,IAAA,CAAKmB,4BAA6BnB,CAAAA,SAAAA,EAAWoB,KAAOwF,EAAAA,WAAAA,EAAayG,WAAAA,CAAAA;AACjE,MAAIvK,IAAAA,gBAAAA,IAAoBA,gBAAiB1C,CAAAA,MAAAA,GAAS,CAAG,EAAA;AACnDJ,QAAAA,SAAAA,CAAUsM,yBAAyBxJ,gBAAAA,CAAAA;AACrC;AACA,MAAIT,IAAAA,SAAAA,CAAU+J,YAAY,cAAgB,EAAA;AACxCpM,QAAUsN,SAAAA,CAAAA,kBAAAA,CAAmBlM,OAAO8L,eAAAA,CAAAA;AACtC;AACA,MAAA;AACF;AAGA,IAAA,MAAM/D,cAAkB9G,GAAAA,SAAAA,CAAUkL,IAAMpE,EAAAA,cAAAA,IAAkB9G,UAAUqK,MAAQvD,EAAAA,cAAAA;AAC5E,IAAMqE,MAAAA,YAAAA,GAAe,KAAK1B,uBACxB1K,CAAAA,KAAAA,EACA8L,iBACAhF,UACAiB,EAAAA,cAAAA,EACA4C,aACA/L,SAAAA,CAAAA;AAEF,IAAA,IAAA,CAAKmB,4BAA6BnB,CAAAA,SAAAA,EAAWoB,KAAOoM,EAAAA,YAAAA,EAAcH,WAAAA,CAAAA;AAClE,IAAIvK,IAAAA,gBAAAA,IAAoBA,gBAAiB1C,CAAAA,MAAAA,GAAS,CAAG,EAAA;AACnDJ,MAAAA,SAAAA,CAAUsM,yBAAyBxJ,gBAAAA,CAAAA;AACrC;AACA,IAAIT,IAAAA,SAAAA,CAAU+J,YAAY,cAAgB,EAAA;AACxC,MAAMqB,MAAAA,YAAAA,GAAgBP,iBAAyBQ,MAAUR,IAAAA,eAAAA;AACzDlN,MAAUsN,SAAAA,CAAAA,kBAAAA,CAAmBlM,OAAOqM,YAAAA,CAAAA;AACtC;AACF;;;;AAKA,EAAA,MAAclB,oBACZlK,CAAAA,SAAAA,EACAN,YACA/B,EAAAA,SAAAA,EACAmD,UACA4I,WACe,EAAA;AACf,IAAA,MAAMa,OAAUvK,GAAAA,SAAAA,CAAUqK,MAAQE,EAAAA,OAAAA,IAAW,EAAA;AAC7C,IAAM1E,MAAAA,UAAAA,GAAa/E,QAAS2J,CAAAA,kBAAAA,EAAwB,IAAA,SAAA;AACpD,IAAA,MAAMK,aAAgB,GAAA,IAAA,CAAKC,oBAAqB/K,CAAAA,SAAAA,EAAW6F,UAAAA,CAAAA;AAC3D,IAAM2E,MAAAA,gBAAAA,GAAmB7M,UAAU8M,kBAAkB,EAAA;AACrD,IAAA,MAAM3D,cAAkB9G,GAAAA,SAAAA,CAAUkL,IAAMpE,EAAAA,cAAAA,IAAkB9G,UAAUqK,MAAQvD,EAAAA,cAAAA;AAE5E,IAAA,KAAA,MAAWwE,cAAcf,OAAS,EAAA;AAChC,MAAA,MAAMgB,aAAaD,UAAWE,CAAAA,UAAAA;AAC9B,MAAMzM,MAAAA,KAAAA,GAAQuM,WAAWvM,KAASwM,IAAAA,UAAAA;AAElC,MAAI,IAAA,EAAEA,cAAc7L,YAAe,CAAA,EAAA;AACjC,QAAA,MAAM,IAAIyK,KAAAA,CAAM,CAAWoB,QAAAA,EAAAA,UAAAA,CAAiC,qBAAA,CAAA,CAAA;AAC9D;AAEA,MAAME,MAAAA,eAAAA,GAAkBH,UAAYzN,EAAAA,QAAAA,GAChC+M,2BAA4BU,CAAAA,UAAAA,CAAWzN,QAAU2M,EAAAA,gBAAAA,CACjDI,GAAAA,2BAAAA,CAA4B5K,SAAUnC,CAAAA,QAAAA,EAAU2M,gBAAAA,CAAAA;AACpD,MAAA,MAAMQ,WAAc,GAAA;QAAE7M,MAAQ2M,EAAAA,aAAAA;QAAejN,QAAU4N,EAAAA;AAAgB,OAAA;AAEvE,MAAA,IAAA,CAAK/N,4BAA6BC,CAAAA,SAAAA,EAAWoB,KAAO+L,EAAAA,aAAAA,EAAeW,eAAAA,CAAAA;AAEnE,MAAMC,MAAAA,aAAAA,GAAgBhM,aAAa6L,UAAAA,CAAAA;AACnC,MAAA,MAAMtL,kBAAqByJ,GAAAA,WAAAA,GAAcA,WAAY6B,CAAAA,UAAAA,CAAc9L,GAAAA,MAAAA;AACnE,MAAA,MAAMT,WAAW,IAAKa,CAAAA,uBAAAA,CAAwBd,KAAO2M,EAAAA,aAAAA,EAAe7F,YAAY0F,UAAY,EAAA;AAC1FzE,QAAAA,cAAAA;AACA7G,QAAAA,kBAAAA;QACAyC,GAAK/E,EAAAA;OACP,CAAA;AAEA,MAAA,IAAA,CAAKmB,4BAA6BnB,CAAAA,SAAAA,EAAWoB,KAAOC,EAAAA,QAAAA,EAAUgM,WAAAA,CAAAA;AAChE;AACF;;;;;AAMQD,EAAAA,oBAAAA,CAAqB/K,WAA0B2L,QAA0B,EAAA;AAC/E,IAAA,MAAMC,MAAO5L,SAAmB4L,EAAAA,GAAAA;AAChC,IAAIA,IAAAA,GAAAA,IAAO,OAAOA,GAAAA,CAAIC,IAAS,KAAA,QAAA,IAAYD,IAAIC,IAAK/N,CAAAA,IAAAA,EAAOC,CAAAA,MAAAA,GAAS,CAAG,EAAA;AACrE,MAAM+N,MAAAA,OAAAA,GAAUF,GAAIC,CAAAA,IAAAA,CAAK/N,IAAI,EAAA;AAC7B,MAAOgO,OAAAA,OAAAA,CAAQC,OAAQ,CAAA,cAAA,EAAgB,EAAA,CAAA;AACzC;AACA,IAAOJ,OAAAA,QAAAA;AACT;;;;AAKQtE,EAAAA,0BAAAA,CACNjK,IACAiH,EAAAA,KAAAA,EACAlG,MACAsJ,EAAAA,QAAAA,EACAX,cACoB,EAAA;AAEpB,IAAkBzC,KAAMA,CAAAA;AACxB,IAAA,MAAMC,gBAAgBD,KAAMC,CAAAA,aAAAA;AAE5B,IAAM0H,MAAAA,UAAAA,GAAa1H,aAAe0H,EAAAA,UAAAA,IAAc,EAAA;AAiBhD,IAAA,IAAIC,gBAAmB5H,GAAAA,KAAAA,CAAMN,QAAYM,IAAAA,KAAAA,CAAMoD,YAAY,EAAC;AAG5D,IAAA,IAAIwE,iBAAiBjI,kBAAoB,EAAA;AACvCiI,MAAmB,gBAAA,GAAA;QACjB,GAAGA,gBAAAA;QACHjI,kBAAoB,EAAA,IAAA,CAAK1G,qBAAsB2O,CAAAA,gBAAAA,CAAiBjI,kBAAkB;AACpF,OAAA;AACF;AAGA,IAAA,IAAIiI,iBAAiB/H,iBAAmB,EAAA;AACtC,MAAA,MAAMgI,eAAkB,GAAA,IAAA,CAAKvM,oBAAqBsM,CAAAA,gBAAAA,CAAiB/H,iBAAiB,CAAA;AAMpF,MAAA,KAAA,MAAW,CAACiI,CAAAA,EAAGnN,QAAAA,CAAAA,IAAakN,eAAiB,EAAA;AAC3C,QAAIlN,IAAAA,QAAAA,CAAS4E,SAAS,YAAc,EAAA;AAClC,UAAMwI,MAAAA,WAAAA,GAAcpN,SAAS+E,QAAUG,EAAAA,iBAAAA;AACvC,UAAA,IAAI,CAACkI,WAAAA,IAAe,EAAEA,WAAAA,YAAuBnP,GAAM,CAAA,EAAA;AACjD+B,YAAAA,QAAAA,CAAS+E,QAAW,GAAA;cAClB,GAAI/E,QAAAA,CAAS+E,YAAY,EAAC;cAC1BG,iBAAmBgI,EAAAA;AACrB,aAAA;AACF;AACF;AACF;AAEAD,MAAmB,gBAAA,GAAA;QACjB,GAAGA,gBAAAA;QACH/H,iBAAmBgI,EAAAA;AACrB,OAAA;AACF;AAEA,IAAA,MAAMG,gBAAmB,GAAA;MACvB,GAAG5E,QAAAA;MACHjB,UAAY,EAAA,IAAA;AACZX,MAAAA,UAAAA,EAAY4B,QAAS5B,CAAAA;AACvB,KAAA;AAEA,IAAMyG,MAAAA,aAAAA,GAAgB7G,qBAAsBoB,CAAAA,qBAAAA,CAAsBwF,gBAAkB,EAAA;MAClF/I,MAAQwD,EAAAA,cAAAA;AACRC,MAAAA,kBAAAA,EAAoBsF,gBAAiB9G,CAAAA;KACvC,CAAA;AAEA,IAAA,MAAMgH,aAAgB,GAAA;MACpB,GAAIN,gBAAAA;AACJ3H,MAAAA;AACF,KAAA;AAEA,IAAA,MAAMkI,eAAeC,wBACnBrP,CAAAA,IAAAA,EACA,WACA,EACA4O,EAAAA,UAAAA,EACAvM,QACAtB,MACA,EAAA;MACEsJ,QAAU6E,EAAAA,aAAAA;MACVvI,QAAUwI,EAAAA;KACZ,CAAA;AAGF,IAAOC,OAAAA,YAAAA;AACT;;;;AAKQzE,EAAAA,iBAAAA,CAAkB1D,KAAqB,EAAA;AAC7C,IAAA,IAAIA,KAAU,KAAA,IAAA,IAAQ,OAAOA,KAAAA,KAAU,QAAU,EAAA;AAC/C,MAAO,OAAA,KAAA;AACT;AAGA,IAAI,IAAA,IAAA,CAAK2E,cAAe3E,CAAAA,KAAAA,CAAQ,EAAA;AAC9B,MAAO,OAAA,KAAA;AACT;AAGA,IAAA,IAAIA,MAAMT,IAAM,EAAA;AACd,MAAO,OAAA,IAAA;AACT;AAGA,IAAA,IAAIS,MAAMD,YAAc,EAAA;AACtB,MAAO,OAAA,IAAA;AACT;AAGA,IAAItB,IAAAA,KAAAA,CAAM+B,OAAQR,CAAAA,KAAAA,CAAQ,EAAA;AACxB,MAAA,OAAOA,MAAMqI,IAAKtD,CAAAA,CAAAA,SAAQ,IAAKrB,CAAAA,iBAAAA,CAAkBqB,IAAAA,CAAAA,CAAAA;AACnD;AAGA,IAAA,KAAA,MAAWuD,IAAQ5P,IAAAA,MAAAA,CAAOsN,MAAOhG,CAAAA,KAAAA,CAAQ,EAAA;AACvC,MAAI,IAAA,IAAA,CAAK0D,iBAAkB4E,CAAAA,IAAAA,CAAO,EAAA;AAChC,QAAO,OAAA,IAAA;AACT;AACF;AAEA,IAAO,OAAA,KAAA;AACT;AAEQ3D,EAAAA,cAAAA,CAAe3E,KAAqB,EAAA;AAC1C,IAAA,OAAOA,SACL,OAAOA,KAAAA,KAAU,QACjB,IAAA,OAAOA,MAAMT,IAAS,KAAA,QAAA,IACtB,MAAUS,IAAAA,KAAAA,IACV,WAAWA,KACX,IAAA,QAAA,IAAYA,KACZ,IAAA,WAAA,IAAeA,SACf,YAAgBA,IAAAA,KAAAA;AACpB;;;;AAKQuD,EAAAA,iBAAAA,CAAkBvD,KAAuC,EAAA;AAC/D,IAAI6C,IAAAA,iBAAAA,CAAkB7C,KAAAA,CAAQ,EAAA;AAC5B,MAAO,OAAA,YAAA;KACEvB,MAAAA,IAAAA,KAAAA,CAAM+B,OAAQR,CAAAA,KAAAA,CAAQ,EAAA;AAC/B,MAAO,OAAA,OAAA;KACEA,MAAAA,IAAAA,KAAAA,IAAS,OAAOA,KAAAA,KAAU,QAAU,EAAA;AAC7C,MAAO,OAAA,QAAA;KACE,MAAA,IAAA,OAAOA,UAAU,QAAU,EAAA;AACpC,MAAO,OAAA,aAAA;KACF,MAAA;AAEL,MAAO,OAAA,aAAA;AACT;AACF;;;;;;AAOQV,EAAAA,6BAAAA,CAA8B3E,QAA6B,EAAA;AAEjE,IAAM4N,MAAAA,QAAAA,GAAW5N,QAAS+E,CAAAA,QAAAA,EAAU6I,QAAY,IAAA,KAAA;AAEhD,IAAA,IAAIA,QAAU,EAAA;AACZ,MAAO,OAAA,KAAA;AACT;AAIA,IAAO,OAAA,IAAA;AACT;AACF,CAAA;AAliCapQ,MAAAA,CAAAA,iBAAAA,EAAAA,kBAAAA,CAAAA;AAAN,IAAMA,gBAAN,GAAA","file":"chunk-WVAX2Q4I.mjs","sourcesContent":["import * as fs from 'fs';\nimport type { DirectiveNode } from '@core/types';\nimport type { Variable, VariableSource, VariableTypeDiscriminator, ExecutableVariable, TemplateVariable, VariableMetadata } from '@core/types/variable';\nimport { \n  createImportedVariable, \n  createObjectVariable,\n  createArrayVariable,\n  createSimpleTextVariable,\n  createPathVariable,\n  createExecutableVariable,\n  createTemplateVariable,\n  createStructuredValueVariable,\n  isExecutable,\n  isExecutableVariable,\n  getEffectiveType,\n  VariableTypeGuards\n} from '@core/types/variable';\nimport { VariableMetadataUtils } from '@core/types/variable';\nimport type { DataLabel } from '@core/types/security';\nimport { makeSecurityDescriptor, mergeDescriptors } from '@core/types/security';\nimport { isStructuredValue } from '@interpreter/utils/structured-value';\nimport type { Environment } from '../../env/Environment';\nimport { ObjectReferenceResolver } from './ObjectReferenceResolver';\nimport { MlldImportError } from '@core/errors';\nimport type { ShadowEnvironmentCapture } from '../../env/types/ShadowEnvironmentCapture';\nimport { ExportManifest } from './ExportManifest';\nimport { astLocationToSourceLocation } from '@core/types';\nimport type { SourceLocation } from '@core/types';\nimport type { SerializedGuardDefinition } from '../../guards';\nimport { varMxToSecurityDescriptor } from '@core/types/variable/VarMxHelpers';\n\nexport interface ModuleProcessingResult {\n  moduleObject: Record<string, any>;\n  frontmatter: Record<string, any> | null;\n  childEnvironment: Environment;\n  guardDefinitions: SerializedGuardDefinition[];\n}\n\n/**\n * Handles variable creation, type inference, and environment merging for imports\n */\nexport class VariableImporter {\n  constructor(private objectResolver: ObjectReferenceResolver) {}\n  \n  /**\n   * Serialize shadow environments for export (Maps to objects)\n   * WHY: Maps don't serialize to JSON, so we convert them to plain objects\n   * GOTCHA: Function references are preserved directly\n   */\n  private serializeShadowEnvs(envs: ShadowEnvironmentCapture): any {\n    const result: any = {};\n    \n    for (const [lang, shadowMap] of Object.entries(envs)) {\n      if (shadowMap instanceof Map && shadowMap.size > 0) {\n        // Convert Map to object\n        const obj: Record<string, any> = {};\n        for (const [name, func] of shadowMap) {\n          obj[name] = func;\n        }\n        result[lang] = obj;\n      }\n    }\n    \n    return result;\n  }\n  \n  /**\n   * Deserialize shadow environments after import (objects to Maps)\n   * WHY: Shadow environments are expected as Maps internally\n   */\n  private deserializeShadowEnvs(envs: any): ShadowEnvironmentCapture {\n    const result: ShadowEnvironmentCapture = {};\n\n    for (const [lang, shadowObj] of Object.entries(envs)) {\n      if (shadowObj && typeof shadowObj === 'object') {\n        // Convert object to Map\n        const map = new Map<string, any>();\n        for (const [name, func] of Object.entries(shadowObj)) {\n          map.set(name, func);\n        }\n        result[lang as keyof ShadowEnvironmentCapture] = map;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Checks whether the requested alias has already been claimed during the\n   * current import pass and throws a detailed error when a collision exists.\n   */\n  private ensureImportBindingAvailable(\n    targetEnv: Environment,\n    name: string,\n    importSource: string,\n    location?: SourceLocation\n  ): void {\n    if (!name || name.trim().length === 0) return;\n    const existingBinding = targetEnv.getImportBinding(name);\n    if (!existingBinding) {\n      return;\n    }\n\n    throw new MlldImportError(\n      `Import collision - '${name}' already imported from ${existingBinding.source}. Alias one of the imports.`,\n      {\n        code: 'IMPORT_NAME_CONFLICT',\n        context: {\n          name,\n          existingSource: existingBinding.source,\n          attemptedSource: importSource,\n          existingLocation: existingBinding.location,\n          newLocation: location,\n          suggestion: \"Use 'as' to alias one of the imports\"\n        },\n        details: {\n          filePath: location?.filePath || existingBinding.location?.filePath,\n          variableName: name\n        }\n      }\n    );\n  }\n\n  /**\n   * Writes the variable and persists the associated binding only after the\n   * assignment succeeds, preventing partially-applied imports from polluting\n   * the collision tracking map.\n   */\n  private setVariableWithImportBinding(\n    targetEnv: Environment,\n    alias: string,\n    variable: Variable,\n    binding: { source: string; location?: SourceLocation }\n  ): void {\n    let shouldPersistBinding = false;\n    try {\n      targetEnv.setVariable(alias, variable);\n      shouldPersistBinding = true;\n    } finally {\n      if (shouldPersistBinding) {\n        targetEnv.setImportBinding(alias, binding);\n      }\n    }\n  }\n\n  /**\n   * Serialize module environment for export (Map to object)\n   * WHY: Maps don't serialize to JSON, so we need to convert to exportable format\n   * IMPORTANT: Use the exact same serialization as processModuleExports to ensure compatibility\n   */\n  private serializeModuleEnv(moduleEnv: Map<string, Variable>): any {\n    // Create a temporary childVars map and reuse processModuleExports logic\n    // Skip module env serialization to prevent infinite recursion, but pass the\n    // current target so we can detect circular references within the env.\n    const tempResult = this.processModuleExports(moduleEnv, {}, true, null, undefined, undefined, moduleEnv);\n    return tempResult.moduleObject;\n  }\n\n  /**\n   * Deserialize module environment after import (object to Map)\n   * IMPORTANT: Reuse createVariableFromValue to ensure proper Variable reconstruction\n   */\n  deserializeModuleEnv(moduleEnv: any): Map<string, Variable> {\n    const result = new Map<string, Variable>();\n    if (moduleEnv && typeof moduleEnv === 'object') {\n      for (const [name, varData] of Object.entries(moduleEnv)) {\n        // Reuse the existing variable creation logic\n        const variable = this.createVariableFromValue(\n          name,\n          varData,\n          'module-env', // Use a special import path to indicate this is from module env\n          name\n        );\n        result.set(name, variable);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Import variables from a processing result into the target environment\n   */\n  async importVariables(\n    processingResult: ModuleProcessingResult,\n    directive: DirectiveNode,\n    targetEnv: Environment\n  ): Promise<void> {\n    const { moduleObject } = processingResult;\n    const serializedMetadata = this.extractMetadataMap(moduleObject);\n    const moduleObjectForImport = serializedMetadata\n      ? Object.fromEntries(Object.entries(moduleObject).filter(([key]) => key !== '__metadata__'))\n      : moduleObject;\n    \n    // Handle variable merging based on import type\n    await this.handleImportType(\n      directive,\n      moduleObjectForImport,\n      targetEnv,\n      processingResult.childEnvironment,\n      serializedMetadata,\n      processingResult.guardDefinitions\n    );\n  }\n\n  /**\n   * Process module exports - either use explicit @data module or auto-generate\n   */\n  processModuleExports(\n    childVars: Map<string, Variable>,\n    parseResult: any,\n    skipModuleEnvSerialization?: boolean,\n    manifest?: ExportManifest | null,\n    childEnv?: Environment,\n    options?: { resolveStrings?: boolean },\n    currentSerializationTarget?: Map<string, Variable>\n  ): { moduleObject: Record<string, any>, frontmatter: Record<string, any> | null; guards: SerializedGuardDefinition[] } {\n    // Extract frontmatter if present\n    const frontmatter = parseResult.frontmatter || null;\n\n    // Always start with auto-export of all top-level variables\n    const moduleObject: Record<string, any> = {};\n    const serializedMetadataMap: Record<string, ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata>> = {};\n    const manifestEntries = manifest?.hasEntries() ? manifest.getEntries() : [];\n    const variableEntries = manifestEntries.filter(entry => entry.kind !== 'guard');\n    const guardEntries = manifestEntries.filter(entry => entry.kind === 'guard');\n    const explicitNames = variableEntries.length > 0 ? variableEntries.map(entry => entry.name) : null;\n    const explicitExports = explicitNames ? new Set(explicitNames) : null;\n    if (explicitNames && explicitNames.length > 0) {\n      for (const name of explicitNames) {\n        if (!childVars.has(name)) {\n          const location = manifest?.getLocation(name);\n          throw new MlldImportError(\n            `Exported name '${name}' is not defined in this module`,\n            {\n              code: 'EXPORTED_NAME_NOT_FOUND',\n              context: {\n                exportName: name,\n                location\n              },\n              details: {\n                filePath: location?.filePath,\n                variableName: name\n              }\n            }\n          );\n        }\n      }\n    }\n\n    const guardNames = guardEntries.map(entry => entry.name);\n    if (guardNames.length > 0) {\n      if (!childEnv) {\n        throw new MlldImportError('Guard exports require a child environment', {\n          code: 'GUARD_EXPORT_CONTEXT',\n          details: { guards: guardNames }\n        });\n      }\n      for (const entry of guardEntries) {\n        const definition = childEnv.getGuardRegistry().getByName(entry.name);\n        if (!definition) {\n          const location = manifest?.getLocation(entry.name);\n          throw new MlldImportError(`Exported guard '${entry.name}' is not defined in this module`, {\n            code: 'EXPORTED_GUARD_NOT_FOUND',\n            context: {\n              guardName: entry.name,\n              location\n            },\n            details: {\n              filePath: location?.filePath,\n              variableName: entry.name\n            }\n          });\n        }\n      }\n    }\n\n    const shouldSerializeModuleEnv = !skipModuleEnvSerialization;\n    let moduleEnvSnapshot: Map<string, Variable> | null = null;\n    const getModuleEnvSnapshot = () => {\n      if (!moduleEnvSnapshot) {\n        moduleEnvSnapshot = new Map(childVars);\n      }\n      return moduleEnvSnapshot;\n    };\n    \n    // Export all top-level variables directly (except system variables)\n    if (process.env.MLLD_DEBUG === 'true') {\n      console.log(`[processModuleExports] childVars size: ${childVars.size}`);\n      console.log(`[processModuleExports] childVars keys: ${Array.from(childVars.keys()).join(', ')}`);\n    }\n    \n    const envSnapshot = childEnv?.getSecuritySnapshot?.();\n    const envDescriptor = envSnapshot\n      ? makeSecurityDescriptor({\n          labels: envSnapshot.labels,\n          taint: envSnapshot.taint,\n          sources: envSnapshot.sources,\n          policyContext: envSnapshot.policy ? { ...envSnapshot.policy } : undefined\n        })\n      : undefined;\n\n    for (const [name, variable] of childVars) {\n      if (explicitExports && !explicitExports.has(name)) {\n        continue;\n      }\n      // Only export legitimate mlld variables - this automatically excludes\n      // system variables like frontmatter (@fm) that don't have valid mlld types\n      if (!this.isLegitimateVariableForExport(variable)) {\n        if (process.env.MLLD_DEBUG === 'true') {\n          console.log(`[processModuleExports] Skipping non-legitimate variable '${name}' with type: ${variable.type}`);\n        }\n        continue;\n      }\n      // For executable variables, we need to preserve the full structure\n      if (variable.type === 'executable') {\n        const execVar = variable as ExecutableVariable;\n\n        // Serialize internal fields (shadow envs, module envs) since Maps do not JSON-serialize\n        let serializedInternal: Record<string, unknown> = { ...(execVar.internal ?? {}) };\n        if (serializedInternal.capturedShadowEnvs) {\n          serializedInternal = {\n            ...serializedInternal,\n            capturedShadowEnvs: this.serializeShadowEnvs(serializedInternal.capturedShadowEnvs)\n          };\n        }\n        if (shouldSerializeModuleEnv) {\n          const capturedEnv =\n            serializedInternal.capturedModuleEnv instanceof Map\n              ? serializedInternal.capturedModuleEnv\n              : getModuleEnvSnapshot();\n          serializedInternal = {\n            ...serializedInternal,\n            capturedModuleEnv: this.serializeModuleEnv(capturedEnv)\n          };\n        } else {\n          // When not adding fresh module env captures (to avoid recursion),\n          // preserve existing capturedModuleEnv from prior imports.\n          //\n          // Key insight: An exe's capturedModuleEnv is circular (and should be deleted)\n          // only if it points to the same env we're currently serializing.\n          // If it's from a different module (e.g., imported exe), preserve it.\n          //\n          // We use currentSerializationTarget (passed from serializeModuleEnv) to detect\n          // circular references, since after deserialization all exes in a module env\n          // point to that same Map.\n          const existingCapture = serializedInternal.capturedModuleEnv;\n          if (existingCapture instanceof Map) {\n            // Check if this is a circular reference\n            if (currentSerializationTarget && existingCapture === currentSerializationTarget) {\n              // Circular - delete to prevent infinite recursion\n              delete serializedInternal.capturedModuleEnv;\n            } else {\n              // Different module's env - serialize and preserve\n              serializedInternal = {\n                ...serializedInternal,\n                capturedModuleEnv: this.serializeModuleEnv(existingCapture)\n              };\n            }\n          }\n          // If already serialized (object), keep it as-is\n          // If undefined, leave it undefined (don't capture new)\n        }\n        \n        // Export executable with all necessary metadata\n        moduleObject[name] = {\n          __executable: true,\n          value: execVar.value,\n          // paramNames removed - they're already in executableDef and shouldn't be exposed as imports\n          executableDef: execVar.internal?.executableDef,\n          internal: serializedInternal\n        };\n      } else if (variable.type === 'template') {\n        const templateVar = variable as TemplateVariable;\n\n        moduleObject[name] = {\n          __template: true,\n          content: templateVar.value,\n          templateSyntax: templateVar.templateSyntax,\n          parameters: templateVar.parameters,\n          templateAst: templateVar.internal?.templateAst || (Array.isArray(templateVar.value) ? templateVar.value : undefined)\n        };\n      } else if (variable.type === 'object' && typeof variable.value === 'object' && variable.value !== null) {\n        // For objects, resolve any variable references within the object\n        const resolvedObject = this.objectResolver.resolveObjectReferences(\n          variable.value,\n          childVars,\n          { resolveStrings: options?.resolveStrings }\n        );\n        moduleObject[name] = resolvedObject;\n      } else {\n        // For other variables, export the value directly\n        moduleObject[name] = variable.value;\n      }\n\n      const descriptor = variable.mx ? varMxToSecurityDescriptor(variable.mx) : undefined;\n      const mergedDescriptor = descriptor && envDescriptor\n        ? mergeDescriptors(descriptor, envDescriptor)\n        : descriptor ?? envDescriptor;\n      const metadataForSerialization: VariableMetadata = {};\n      if (mergedDescriptor) {\n        metadataForSerialization.security = mergedDescriptor;\n      }\n      if (variable.internal?.capability) {\n        metadataForSerialization.capability = variable.internal.capability;\n      }\n      const serializedMetadata = VariableMetadataUtils.serializeSecurityMetadata(metadataForSerialization);\n      if (serializedMetadata) {\n        serializedMetadataMap[name] = serializedMetadata;\n      }\n    }\n    if (Object.keys(serializedMetadataMap).length > 0) {\n      moduleObject.__metadata__ = serializedMetadataMap;\n    }\n    \n    const guards: SerializedGuardDefinition[] =\n      guardNames.length > 0 && childEnv\n        ? childEnv.serializeGuardsByNames(guardNames)\n        : [];\n\n    return {\n      moduleObject,\n      frontmatter,\n      guards\n    };\n  }\n\n  /**\n   * Create a variable from an imported value, inferring the type\n   */\n  createVariableFromValue(\n    name: string,\n    value: any,\n    importPath: string,\n    originalName?: string,\n    options?: {\n      securityLabels?: DataLabel[];\n      serializedMetadata?: ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata> | undefined;\n      env?: Environment;\n    }\n  ): Variable {\n    const source: VariableSource = {\n      directive: 'var',\n      syntax: Array.isArray(value) ? 'array' : \n              (value && typeof value === 'object') ? 'object' : 'quoted',\n      hasInterpolation: false,\n      isMultiLine: false\n    };\n    const deserialized = VariableMetadataUtils.deserializeSecurityMetadata(options?.serializedMetadata);\n    const snapshot = options?.env?.getSecuritySnapshot?.();\n    let snapshotDescriptor = 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    let combinedDescriptor = deserialized.security;\n    if (snapshotDescriptor) {\n      combinedDescriptor = combinedDescriptor\n        ? mergeDescriptors(combinedDescriptor, snapshotDescriptor)\n        : snapshotDescriptor;\n    }\n    const baseMetadata = {\n      isImported: true,\n      importPath,\n      originalName: originalName !== name ? originalName : undefined,\n      definedAt: { line: 0, column: 0, filePath: importPath },\n      ...deserialized\n    };\n    const initialMetadata = VariableMetadataUtils.applySecurityMetadata(baseMetadata, {\n      labels: options?.securityLabels,\n      existingDescriptor: combinedDescriptor\n    });\n    const buildMetadata = (extra?: VariableMetadata): VariableMetadata =>\n      VariableMetadataUtils.applySecurityMetadata(\n        {\n          ...initialMetadata,\n          ...(extra || {})\n        },\n        {\n          labels: options?.securityLabels,\n          existingDescriptor: initialMetadata.security\n        }\n      );\n\n    if (isStructuredValue(value)) {\n      return createStructuredValueVariable(\n        name,\n        value,\n        source,\n        buildMetadata({\n          isStructuredValue: true,\n          structuredValueType: value.type\n        })\n      );\n    }\n\n    // Check if this is an executable export\n    if (value && typeof value === 'object' && '__executable' in value && value.__executable) {\n      return this.createExecutableFromImport(name, value, source, buildMetadata(), options?.securityLabels);\n    }\n    \n    // Check if this is a template export\n    if (value && typeof value === 'object' && (value as any).__template) {\n      const templateSource: VariableSource = {\n        directive: 'var',\n        syntax: 'template',\n        hasInterpolation: true,\n        isMultiLine: true\n      };\n      const tmplMetadata = buildMetadata();\n      const templateOptions = {\n        metadata: tmplMetadata,\n        internal: {\n          templateAst: (value as any).templateAst\n        }\n      };\n      return createTemplateVariable(\n        name,\n        (value as any).content,\n        (value as any).parameters,\n        (value as any).templateSyntax === 'tripleColon' ? 'tripleColon' : 'doubleColon',\n        templateSource,\n        templateOptions\n      );\n    }\n\n    // Infer the variable type from the value\n    const originalType = this.inferVariableType(value);\n\n    // Preserve primitive types (no stringification) so math/boolean logic works in eval\n    let processedValue = value;\n    \n    // For array types, create an ArrayVariable to preserve array behaviors\n    if (originalType === 'array' && Array.isArray(processedValue)) {\n      const isComplexArray = this.hasComplexContent(processedValue);\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        console.error('[VariableImporter] create array variable', {\n          name,\n          importPath,\n          isComplexArray,\n          sample: processedValue.slice(0, 2)\n        });\n      }\n\n      return createArrayVariable(\n        name,\n        processedValue,\n        isComplexArray,\n        source,\n        buildMetadata({\n          isImported: true,\n          importPath,\n          originalName: originalName !== name ? originalName : undefined\n        })\n      );\n    }\n\n    // For object types, create an ObjectVariable to preserve field access capability\n    if (originalType === 'object') {\n      const normalizedObject = this.unwrapArraySnapshots(processedValue, importPath);\n      // Check if the object contains complex AST nodes that need evaluation\n      const isComplex = this.hasComplexContent(normalizedObject);\n      if (process.env.MLLD_DEBUG_FIX === 'true') {\n        console.error('[VariableImporter] create object variable', {\n          name,\n          importPath,\n          isComplex,\n          keys: Object.keys(normalizedObject || {}).slice(0, 5),\n          agentRosterPreview: normalizedObject && (normalizedObject as any).agent_roster\n        });\n        try {\n          fs.appendFileSync(\n            '/tmp/mlld-debug.log',\n            JSON.stringify({\n              source: 'VariableImporter',\n              name,\n              importPath,\n              isComplex,\n              keys: Object.keys(normalizedObject || {}).slice(0, 5),\n              agentRosterType: normalizedObject && typeof (normalizedObject as any).agent_roster,\n              agentRosterIsVariable: this.isVariableLike((normalizedObject as any).agent_roster),\n              agentRosterIsArray: Array.isArray((normalizedObject as any).agent_roster)\n            }) + '\\n'\n          );\n        } catch {}\n      }\n      \n      return createObjectVariable(\n        name,\n        normalizedObject,\n        isComplex, // Mark as complex if it contains AST nodes\n        source,\n        buildMetadata({\n          isImported: true,\n          importPath,\n          originalName: originalName !== name ? originalName : undefined\n        })\n      );\n    }\n    \n    // For non-objects, use createImportedVariable to preserve the original type info\n    return createImportedVariable(\n      name,\n      processedValue,\n      originalType,\n      importPath,\n      false,\n      originalName || name,\n      source,\n      buildMetadata()\n    );\n  }\n\n  private unwrapArraySnapshots(value: any, importPath: string): any {\n    if (Array.isArray(value)) {\n      return value.map(item => this.unwrapArraySnapshots(item, importPath));\n    }\n\n    if (value && typeof value === 'object') {\n      if ((value as any).__arraySnapshot) {\n        const snapshot = value as { value: any[]; metadata?: Record<string, any>; isComplex?: boolean; name?: string };\n        const source: VariableSource = {\n          directive: 'var',\n          syntax: 'array',\n          hasInterpolation: false,\n          isMultiLine: false\n        };\n        const arrayMetadata = {\n          ...(snapshot.metadata || {}),\n          isImported: true,\n          importPath,\n          originalName: snapshot.name\n        };\n        const normalizedElements = Array.isArray(snapshot.value)\n          ? snapshot.value.map(item => this.unwrapArraySnapshots(item, importPath))\n          : [];\n        const arrayName = snapshot.name || 'imported_array';\n        return createArrayVariable(arrayName, normalizedElements, snapshot.isComplex === true, source, arrayMetadata);\n      }\n\n      // Reconstruct __executable markers back to proper ExecutableVariables\n      // This ensures isExecutableVariable() works on object properties\n      if ((value as any).__executable) {\n        const source: VariableSource = {\n          directive: 'exe',\n          syntax: 'braces',\n          hasInterpolation: false,\n          isMultiLine: false\n        };\n        return this.createExecutableFromImport(\n          'property',\n          value,\n          source,\n          { isImported: true, importPath }\n        );\n      }\n\n      const result: Record<string, any> = {};\n      for (const [key, entry] of Object.entries(value)) {\n        result[key] = this.unwrapArraySnapshots(entry, importPath);\n      }\n      return result;\n    }\n\n    return value;\n  }\n\n  /**\n   * Create a namespace variable for imports with aliased wildcards (e.g., * as @config)\n   */\n  createNamespaceVariable(\n    alias: string,\n    moduleObject: Record<string, any>,\n    importPath: string,\n    securityLabels?: DataLabel[],\n    metadataMap?: Record<string, ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata> | undefined>,\n    env?: Environment\n  ): Variable {\n    const source: VariableSource = {\n      directive: 'var',\n      syntax: 'object',\n      hasInterpolation: false,\n      isMultiLine: false\n    };\n\n    // Check if the namespace contains complex content (like executables)\n    const isComplex = this.hasComplexContent(moduleObject);\n    \n    const snapshot = env?.getSecuritySnapshot?.();\n    let snapshotDescriptor = 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    const metadata = VariableMetadataUtils.applySecurityMetadata(\n      {\n        isImported: true,\n        importPath,\n        definedAt: { line: 0, column: 0, filePath: importPath },\n        namespaceMetadata: metadataMap\n      },\n      {\n        labels: securityLabels,\n        existingDescriptor: snapshotDescriptor\n      }\n    );\n    const namespaceOptions = {\n      metadata,\n      internal: { isNamespace: true }\n    };\n\n    return createObjectVariable(\n      alias,\n      moduleObject,\n      isComplex, // Mark as complex if it contains AST nodes or executables\n      source,\n      namespaceOptions\n    );\n  }\n\n  private extractMetadataMap(\n    moduleObject: Record<string, any>\n  ): Record<string, ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata> | undefined> | undefined {\n    const container = (moduleObject as Record<string, any>).__metadata__;\n    if (!container || typeof container !== 'object') {\n      return undefined;\n    }\n\n    const result: Record<string, ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata> | undefined> = {};\n    for (const [key, value] of Object.entries(container)) {\n      result[key] = value as ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata>;\n    }\n    return result;\n  }\n\n  /**\n   * Merge variables into the target environment based on import type\n   */\n  private async handleImportType(\n    directive: DirectiveNode,\n    moduleObject: Record<string, any>,\n    targetEnv: Environment,\n    childEnv: Environment,\n    metadataMap?: Record<string, ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata> | undefined>,\n    guardDefinitions?: SerializedGuardDefinition[]\n  ): Promise<void> {\n    if (directive.subtype === 'importPolicy') {\n      await this.handleNamespaceImport(\n        directive,\n        moduleObject,\n        targetEnv,\n        childEnv,\n        metadataMap,\n        guardDefinitions\n      );\n    } else if (directive.subtype === 'importAll') {\n      throw new MlldImportError(\n        'Wildcard imports \\'/import { * }\\' are no longer supported. ' +\n        'Use namespace imports instead: \\'/import \"file\"\\' or \\'/import \"file\" as @name\\'',\n        directive.location,\n        {\n          suggestion: 'Change \\'/import { * } from \"file\"\\' to \\'/import \"file\"\\''\n        }\n      );\n    } else if (directive.subtype === 'importNamespace') {\n      await this.handleNamespaceImport(\n        directive,\n        moduleObject,\n        targetEnv,\n        childEnv,\n        metadataMap,\n        guardDefinitions\n      );\n    } else if (directive.subtype === 'importSelected') {\n      if (guardDefinitions && guardDefinitions.length > 0) {\n        targetEnv.registerSerializedGuards(guardDefinitions);\n      }\n      await this.handleSelectedImport(directive, moduleObject, targetEnv, childEnv, metadataMap);\n    } else {\n      throw new Error(`Unknown import subtype: ${directive.subtype}`);\n    }\n  }\n\n  /**\n   * Handle namespace imports\n   */\n  private async handleNamespaceImport(\n    directive: DirectiveNode,\n    moduleObject: Record<string, any>,\n    targetEnv: Environment,\n    childEnv: Environment,\n    metadataMap?: Record<string, ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata> | undefined>,\n    guardDefinitions?: SerializedGuardDefinition[]\n  ): Promise<void> {\n    // For shorthand imports, namespace is stored as an array in values.namespace\n    const namespaceNodes = directive.values?.namespace;\n    const alias = (namespaceNodes && Array.isArray(namespaceNodes) && namespaceNodes[0]?.content) \n      ? namespaceNodes[0].content \n      : directive.values?.imports?.[0]?.alias;\n\n    if (!alias) {\n      throw new Error('Namespace import missing alias');\n    }\n\n    const importerFilePath = targetEnv.getCurrentFilePath();\n    const aliasLocationNode = namespaceNodes && Array.isArray(namespaceNodes) ? namespaceNodes[0] : undefined;\n    const aliasLocation = aliasLocationNode?.location\n      ? astLocationToSourceLocation(aliasLocationNode.location, importerFilePath)\n      : astLocationToSourceLocation(directive.location, importerFilePath);\n\n    // Namespace imports always create objects with exported properties\n    const namespaceObject = moduleObject;\n    \n    const importPath = childEnv.getCurrentFilePath() || 'unknown';\n    const importDisplay = this.getImportDisplayPath(directive, importPath);\n    const bindingInfo = { source: importDisplay, location: aliasLocation };\n\n    this.ensureImportBindingAvailable(targetEnv, alias, importDisplay, aliasLocation);\n\n    // If the unwrapped object is a template export, create a template variable instead\n    if (namespaceObject && typeof namespaceObject === 'object' && (namespaceObject as any).__template) {\n      const templateVar = this.createVariableFromValue(alias, namespaceObject, importPath, undefined, {\n        env: targetEnv\n      });\n      this.setVariableWithImportBinding(targetEnv, alias, templateVar, bindingInfo);\n      if (guardDefinitions && guardDefinitions.length > 0) {\n        targetEnv.registerSerializedGuards(guardDefinitions);\n      }\n      if (directive.subtype === 'importPolicy') {\n        targetEnv.recordPolicyConfig(alias, namespaceObject);\n      }\n      return;\n    }\n\n    // Create namespace variable with the (potentially unwrapped) object\n    const securityLabels = (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined;\n    const namespaceVar = this.createNamespaceVariable(\n      alias,\n      namespaceObject,\n      importPath,\n      securityLabels,\n      metadataMap,\n      targetEnv\n    );\n    this.setVariableWithImportBinding(targetEnv, alias, namespaceVar, bindingInfo);\n    if (guardDefinitions && guardDefinitions.length > 0) {\n      targetEnv.registerSerializedGuards(guardDefinitions);\n    }\n    if (directive.subtype === 'importPolicy') {\n      const policyConfig = (namespaceObject as any)?.config ?? namespaceObject;\n      targetEnv.recordPolicyConfig(alias, policyConfig);\n    }\n  }\n\n  /**\n   * Handle selected imports\n   */\n  private async handleSelectedImport(\n    directive: DirectiveNode,\n    moduleObject: Record<string, any>,\n    targetEnv: Environment,\n    childEnv: Environment,\n    metadataMap?: Record<string, ReturnType<typeof VariableMetadataUtils.serializeSecurityMetadata> | undefined>\n  ): Promise<void> {\n    const imports = directive.values?.imports || [];\n    const importPath = childEnv.getCurrentFilePath() || 'unknown';\n    const importDisplay = this.getImportDisplayPath(directive, importPath);\n    const importerFilePath = targetEnv.getCurrentFilePath();\n    const securityLabels = (directive.meta?.securityLabels || directive.values?.securityLabels) as DataLabel[] | undefined;\n\n    for (const importItem of imports) {\n      const importName = importItem.identifier;\n      const alias = importItem.alias || importName;\n\n      if (!(importName in moduleObject)) {\n        throw new Error(`Import '${importName}' not found in module`);\n      }\n\n      const bindingLocation = importItem?.location\n        ? astLocationToSourceLocation(importItem.location, importerFilePath)\n        : astLocationToSourceLocation(directive.location, importerFilePath);\n      const bindingInfo = { source: importDisplay, location: bindingLocation };\n\n      this.ensureImportBindingAvailable(targetEnv, alias, importDisplay, bindingLocation);\n\n      const importedValue = moduleObject[importName];\n      const serializedMetadata = metadataMap ? metadataMap[importName] : undefined;\n      const variable = this.createVariableFromValue(alias, importedValue, importPath, importName, {\n        securityLabels,\n        serializedMetadata,\n        env: targetEnv\n      });\n\n      this.setVariableWithImportBinding(targetEnv, alias, variable, bindingInfo);\n    }\n  }\n\n  /**\n   * Produces a human-readable source string for error messages, stripping any\n   * quotes that appeared in the original directive.\n   */\n  private getImportDisplayPath(directive: DirectiveNode, fallback: string): string {\n    const raw = (directive as any)?.raw;\n    if (raw && typeof raw.path === 'string' && raw.path.trim().length > 0) {\n      const trimmed = raw.path.trim();\n      return trimmed.replace(/^['\"]|['\"]$/g, '');\n    }\n    return fallback;\n  }\n\n  /**\n   * Create an executable variable from import metadata\n   */\n  private createExecutableFromImport(\n    name: string,\n    value: any,\n    source: VariableSource,\n    metadata: any,\n    securityLabels?: DataLabel[]\n  ): ExecutableVariable {\n    // This is an executable variable - reconstruct it properly\n    const execValue = value.value;\n    const executableDef = value.executableDef;\n    // Get paramNames from executableDef where it's properly stored\n    const paramNames = executableDef?.paramNames || [];\n    \n    // The executable definition contains all the needed information\n    // We just need to create a dummy ExecutableVariable that preserves it\n    // The actual execution will use the executableDef from metadata\n    // OLD CODE that might lose metadata:\n    // return createExecutableVariable(\n    //   name,\n    //   value.value.type,\n    //   value.value.template || '',\n    //   value.value.paramNames || [],\n    //   value.value.language,\n    //   source,\n    //   metadata\n    // );\n    \n    // NEW CODE: Ensure all metadata is preserved\n    let originalInternal = value.internal || value.metadata || {};\n\n    // Deserialize shadow environments if present\n    if (originalInternal.capturedShadowEnvs) {\n      originalInternal = {\n        ...originalInternal,\n        capturedShadowEnvs: this.deserializeShadowEnvs(originalInternal.capturedShadowEnvs)\n      };\n    }\n\n    // Deserialize module environment if present\n    if (originalInternal.capturedModuleEnv) {\n      const deserializedEnv = this.deserializeModuleEnv(originalInternal.capturedModuleEnv);\n\n      // IMPORTANT: Each executable in the module env needs to have access to the full env\n      // This allows command-refs to find their siblings.\n      // BUT: Only set capturedModuleEnv if the exe doesn't already have one from a prior import.\n      // Imported exes preserve their original scope chain.\n      for (const [_, variable] of deserializedEnv) {\n        if (variable.type === 'executable') {\n          const existingEnv = variable.internal?.capturedModuleEnv;\n          if (!existingEnv || !(existingEnv instanceof Map)) {\n            variable.internal = {\n              ...(variable.internal ?? {}),\n              capturedModuleEnv: deserializedEnv\n            };\n          }\n        }\n      }\n\n      originalInternal = {\n        ...originalInternal,\n        capturedModuleEnv: deserializedEnv\n      };\n    }\n    \n    const enhancedMetadata = {\n      ...metadata,\n      isImported: true,\n      importPath: metadata.importPath\n    };\n\n    const finalMetadata = VariableMetadataUtils.applySecurityMetadata(enhancedMetadata, {\n      labels: securityLabels,\n      existingDescriptor: enhancedMetadata.security\n    });\n\n    const finalInternal = {\n      ...(originalInternal as Record<string, unknown>),\n      executableDef\n    };\n\n    const execVariable = createExecutableVariable(\n      name,\n      'command', // Default type - the real type is in executableDef\n      '', // Empty template - the real template is in executableDef\n      paramNames,\n      undefined, // No language here - it's in executableDef\n      source,\n      {\n        metadata: finalMetadata,\n        internal: finalInternal\n      }\n    );\n    \n    return execVariable;\n  }\n\n  /**\n   * Check if a value contains complex AST nodes that need evaluation\n   */\n  private hasComplexContent(value: any): boolean {\n    if (value === null || typeof value !== 'object') {\n      return false;\n    }\n\n    // Imported variables already hold evaluated content; do not treat them as complex\n    if (this.isVariableLike(value)) {\n      return false;\n    }\n\n    // Check if this is an AST node with a type\n    if (value.type) {\n      return true;\n    }\n    \n    // Check if it has __executable objects (from resolved executables)\n    if (value.__executable) {\n      return true;\n    }\n    \n    // Recursively check arrays\n    if (Array.isArray(value)) {\n      return value.some(item => this.hasComplexContent(item));\n    }\n    \n    // Recursively check object properties\n    for (const prop of Object.values(value)) {\n      if (this.hasComplexContent(prop)) {\n        return true;\n      }\n    }\n    \n    return false;\n  }\n\n  private isVariableLike(value: any): boolean {\n    return value &&\n      typeof value === 'object' &&\n      typeof value.type === 'string' &&\n      'name' in value &&\n      'value' in value &&\n      'source' in value &&\n      'createdAt' in value &&\n      'modifiedAt' in value;\n  }\n\n  /**\n   * Infer variable type from value\n   */\n  private inferVariableType(value: any): VariableTypeDiscriminator {\n    if (isStructuredValue(value)) {\n      return 'structured';\n    } else if (Array.isArray(value)) {\n      return 'array';\n    } else if (value && typeof value === 'object') {\n      return 'object';\n    } else if (typeof value === 'string') {\n      return 'simple-text';\n    } else {\n      // Numbers, booleans, etc. convert to text\n      return 'simple-text';\n    }\n  }\n\n  /**\n   * Check if a variable is a legitimate mlld variable that can be exported/imported.\n   * System variables (tracked via internal.isSystem) are excluded\n   * to prevent namespace collisions when importing multiple modules with system variables like @fm.\n   */\n  private isLegitimateVariableForExport(variable: Variable): boolean {\n    // System variables (like @fm) should not be exported\n    const isSystem = variable.internal?.isSystem ?? false;\n\n    if (isSystem) {\n      return false;\n    }\n    \n    // All user-created variables are exportable\n    // This includes variables created by /var, /exe, /path directives\n    return true;\n  }\n}\n"]}