const loaded=Object.keys(createRequire(command[1]).cache).filter(file=>file.endsWith('.node')).sort();

if(JSON.stringify(loaded)!==JSON.stringify(bindingFiles.map(file=>path.join(root,file)).sort()))throw Error('Unreviewed loaded native binding');

return bindingFiles.map(file=>{const row=inventory.installedInputs.find(input=>input.file===file&&input.kind==='file');if(!row||hash(fs.readFileSync(path.join(root,file)))!==row.sha256)throw Error('Loaded native binding bytes changed');return {file,sha256:row.sha256};});

const allowed=new Set(['--','color','config','c','root','run','watch','includeTaskLocation','reporters','outputFile','cache']);

if(Object.keys(options).some(key=>!allowed.has(key))||Object.keys(overrides).sort().join(',')!=='logLevel,plugins'||overrides.logLevel!=='silent'||options.cache!==false||options.run!==true||options.watch!==false||options.includeTaskLocation!==true||options.root!==undefined&&options.root!==root||options['--']!==undefined&&(!Array.isArray(options['--'])||options['--'].length)||options.color!==undefined&&typeof options.color!=='boolean')return false;

const config=path.join(root,profile.observerConfiguration.file);

if(typeof options.config!=='string'||path.resolve(root,options.config)!==config||options.c!==undefined&&path.resolve(root,options.c)!==config)return false;

if(options.reporters!==undefined&&(!Array.isArray(options.reporters)||options.reporters.length!==2||options.reporters[0]!=='json'||!(options.reporters[1] instanceof TestLoreVitestCaseReporter)))return false;

if(options.outputFile!==undefined&&(typeof options.outputFile!=='string'||!path.isAbsolute(options.outputFile)))return false;

return Array.isArray(overrides.plugins)&&overrides.plugins.length===1&&isReviewedUnimportFactoryPlugin(overrides.plugins[0],root,profile.registrationContracts[0]);

if(depth>15)throw Error('Unbounded runtime options');

if(typeof value==='string')return value.replaceAll(root,'<project>');

if(value===null||['number','boolean','undefined'].includes(typeof value))return value??null;

if(typeof value==='function')return {functionSha256:hash(Function.prototype.toString.call(value))};

if(value instanceof RegExp)return {regexp:value.source,flags:value.flags};

if(typeof value!=='object'||seen.has(value))throw Error('Unsupported runtime options');

seen.add(value);let result;

if(Array.isArray(value))result=value.map(item=>primitive(item,root,depth+1,seen));

else{result={};for(const key of Object.keys(value).sort()){const descriptor=Object.getOwnPropertyDescriptor(value,key);if(!descriptor)throw Error('Missing runtime options descriptor');result[key]=Object.hasOwn(descriptor,'value')?primitive(descriptor.value,root,depth+1,seen):{getterSha256:typeof descriptor.get==='function'?hash(Function.prototype.toString.call(descriptor.get)):null,setterSha256:typeof descriptor.set==='function'?hash(Function.prototype.toString.call(descriptor.set)):null,value:primitive(value[key],root,depth+1,seen)};}}

seen.delete(value);return result;

const lists=[context.vite.config.plugins,context.vite.config.inlineConfig.plugins,...Object.values(context.projects[0].vite.environments).map(environment=>environment.config.plugins)];

const objects=new Map();

function walk(value,depth){if(!value||!['object','function'].includes(typeof value)||objects.has(value)||depth>5)return;const descriptors=Object.getOwnPropertyDescriptors(value);objects.set(value,descriptors);for(const descriptor of Object.values(descriptors))if(Object.hasOwn(descriptor,'value')&&typeof descriptor.value!=='function')walk(descriptor.value,depth+1);}

for(const list of lists)walk(list,0);

return ()=>{for(const [object,descriptors] of objects){const current=Object.getOwnPropertyDescriptors(object),keys=Reflect.ownKeys(descriptors),actual=Reflect.ownKeys(current);if(keys.length!==actual.length||keys.some(key=>!actual.includes(key)||Object.keys(descriptors[key]).some(field=>!Object.is(descriptors[key][field],current[key]?.[field]))))throw Error('Observed native plugin identity or hook changed');}};

if(context.projects.length!==1)throw Error('Runtime precision requires exactly one native project');

const project=context.projects[0],config=project.config,vite=project.vite.config;

if(context.cache?.results?.getCachePath()!==null||config.cache!==false)throw Error('Native writable results cache must be disabled');

if(project!==context.getRootProject()||config.name!==''||config.root!==root||config.environment!=='node'||config.pool!=='forks'||config.isolate!==true||config.typecheck?.enabled!==false||config.browser?.enabled!==false||config.coverage?.enabled!==false||config.setupFiles?.length||config.globalSetup?.length||config.execArgv?.length||config.deps?.optimizer?.client?.enabled!==false||config.deps?.optimizer?.ssr?.enabled!==false||config.env&&Object.keys(config.env).length||config.provide&&Object.keys(config.provide).length)throw Error('Unsupported effective native test options');

if(Object.keys(project.vite.environments).sort().join(',')!==environments.join(',')||vite.configFile!==path.join(root,profile.observerConfiguration.file)||[...new Set(vite.configFileDependencies)].sort().join('\n')!==[path.join(root,'vitest.config.ts'),path.join(root,profile.observerConfiguration.file)].sort().join('\n'))throw Error('Incomplete effective native configuration/environment closure');

const originalFields=['cache','environmentOptions','typecheck','browser','pool','isolate','setupFiles','globalSetup','execArgv','deps','css','server','experimental','_moduleRunnerOptions','_scriptDefines','defines','snapshotSerializers','injectCjsGlobals','globals','viteOverrides','sharedViteServer'];

const viteFields=['oxc','esbuild','ssr','resolve','define','mode','command','isProduction','env','json','assetsInclude','rawAssetsInclude','experimental','future','worker','envDir','publicDir','appType','cacheDir'];

const testOptions=Object.fromEntries(originalFields.map(key=>[key,config[key]])),viteOptions=Object.fromEntries(viteFields.map(key=>[key,vite[key]]));

const env=Object.fromEntries(environments.map(name=>{const value=project.vite.environments[name];if(value.config.consumer!==(name==='client'?'client':'server')||value.config.isBundled!==false)throw Error('Unsupported native transform environment');return [name,primitive({...value.config,plugins:value.config.plugins.map(plugin=>({name:plugin.name,keys:Object.keys(plugin).sort(),hooks:Object.fromEntries(Object.entries(plugin).filter(([,hook])=>typeof hook==='function').map(([key,hook])=>[key,hash(Function.prototype.toString.call(hook))]))}))},root)];}));

return {testOptions:primitive(testOptions,root),viteOptions:primitive(viteOptions,root),environments:env,plugins:primitive(vite.plugins.map(plugin=>({name:plugin.name,keys:Object.keys(plugin).sort(),hooks:Object.fromEntries(Object.entries(plugin).filter(([,hook])=>typeof hook==='function').map(([key,hook])=>[key,hash(Function.prototype.toString.call(hook))]))})),root)};

let inventory;try{if(caseProfile?.profile?.profile!=='unimport-detect-factory-runtime-v1'||!caseProfile.observerConfiguration||!constructorOptions(root,caseProfile,options,overrides)||!nativeEnvironment())return null;inventory=captureUnimportRuntimeEvidence(root,command,caseProfile);}catch{return null;}

if(!supportedInventory(inventory))return null;

const require=createRequire(command[1]),canonical=await import(pathToFileURL(require.resolve('vitest/node')).href);

if(vitestModule.createVitest!==canonical.createVitest||vitestModule.parseCLI!==canonical.parseCLI)return null;

const context=await canonical.createVitest(options,overrides);

try{

const projection=observeUnimportRuntimeOptions(context,root,caseProfile),checkPlugins=pluginSnapshot(context),bindings=nativeBindings(root,command,inventory);

if(!effectivePins(inventory).includes(hash(projection)))throw Error('Unreviewed effective transform profile');

const canaries=await transformCanaries(context,root);checkPlugins();

if(hash(canaries)!==CANARIES_SHA)throw Error('Unreviewed native transform canary outputs');

assertFreshUnimportRuntimeEvidence(inventory);

contexts.set(context,{root,command:[...command],caseProfile,inventory,projection,canaries,checkPlugins,bindings});

return context;

}catch(error){

// Once executable configuration has run, retain the same native context as

// conservative. Never evaluate configuration twice to recover authority.

try{assertFreshUnimportRuntimeEvidence(inventory);}catch(freshnessError){await context.close();throw freshnessError;}

return context;

}

const record=contexts.get(context);if(!record)return null;record.checkPlugins();

if(!nativeEnvironment()||JSON.stringify(nativeBindings(record.root,record.command,record.inventory))!==JSON.stringify(record.bindings))throw Error('Native execution environment or binding changed');

if(hash(observeUnimportRuntimeOptions(context,record.root,record.caseProfile))!==hash(record.projection))throw Error('Effective runtime transform options changed');

assertFreshUnimportRuntimeEvidence(record.inventory);

const value={schemaVersion:1,profile:PROFILE,inventoryDigest:record.inventory.digest,installedSha256:hash(record.inventory.installedInputs),implementationSha256:IMPLEMENTATION_SHA,installedDirectoriesSha256:DIRECTORIES_SHA,nodeSha256:NODE_SHA,nativeBindings:record.bindings,effective:record.projection,effectiveSha256:hash(record.projection),canaries:record.canaries,files:[...record.inventory.testFiles],closedConfigurationInputs:record.inventory.configurationInputs,observerConfiguration:record.inventory.observerConfiguration};return {...value,digest:hash(value)};

try{

if(!supportedInventory(inventory)||!value||value.schemaVersion!==1||value.profile!==PROFILE||value.inventoryDigest!==inventory.digest||value.installedSha256!==hash(inventory.installedInputs)||value.implementationSha256!==IMPLEMENTATION_SHA||value.installedDirectoriesSha256!==DIRECTORIES_SHA||value.nodeSha256!==NODE_SHA||!effectivePins(inventory).includes(value.effectiveSha256)||hash(value.effective)!==value.effectiveSha256||JSON.stringify(value.files)!==JSON.stringify(inventory.testFiles)||JSON.stringify(value.closedConfigurationInputs)!==JSON.stringify(inventory.configurationInputs)||JSON.stringify(value.observerConfiguration)!==JSON.stringify(inventory.observerConfiguration))return null;

if(JSON.stringify(value.nativeBindings)!==JSON.stringify(bindingFiles.map(file=>({file,sha256:inventory.installedInputs.find(input=>input.file===file)?.sha256}))))return null;

assertFreshUnimportRuntimeEvidence(inventory);

const {digest,...body}=value;if(Object.keys(value).sort().join(',')!=='canaries,closedConfigurationInputs,digest,effective,effectiveSha256,files,implementationSha256,installedDirectoriesSha256,installedSha256,inventoryDigest,nativeBindings,nodeSha256,observerConfiguration,profile,schemaVersion'||hash(body)!==digest||!Array.isArray(value.canaries)||value.canaries.length!==15||hash(value.canaries)!==CANARIES_SHA)return null;

for(const [index,row]of value.canaries.entries()){const environment=environments[Math.floor(index/5)],kind=Object.keys(canarySources)[index%5];if(row.environment!==environment||row.kind!==kind||row.id!=='<project>/src/utils.ts?testlore_runtime='+kind||row.sourceSha256!==hash(canarySources[kind])||row.retainsRuntime!==['mixed','sideeffect'].includes(kind)||!['outputSha256','mapSha256'].every(key=>/^[a-f0-9]{64}$/.test(row[key])))return null;}

return structuredClone(value);

}catch{return null;}