import { test, expect, vi } from 'vitest'
import { types } from 'node:util'
const kind="named-async-generator"
const form="object"
function argument(value){return form==='object'?{value}:[value]}
function shape(value){if(value===null||(typeof value!=='object'&&typeof value!=='function'))return{type:typeof value,value};return{type:typeof value,brand:types.isModuleNamespaceObject(value),keys:Reflect.ownKeys(value).map(String),prototype:Object.getPrototypeOf(value)===null?'null':Object.getPrototypeOf(value)===Object.prototype?'Object.prototype':Object.getPrototypeOf(value)===Function.prototype?'Function.prototype':Object.prototype.toString.call(Object.getPrototypeOf(value)),tag:value[Symbol.toStringTag]??null,extensible:Object.isExtensible(value),sealed:Object.isSealed(value),frozen:Object.isFrozen(value),descriptors:Reflect.ownKeys(value).map(key=>{const d=Object.getOwnPropertyDescriptor(value,key);return{key:String(key),valueType:typeof d.value,get:typeof d.get,set:typeof d.set,writable:d.writable??null,enumerable:d.enumerable,configurable:d.configurable}})}}
function matrix(values){return values.map(value=>values.map(other=>value===other))}
function counts(){return{root:globalThis.__cjsDestructureRoot??0,dependency:globalThis.__cjsDestructureDependency??0,unused:globalThis.__cjsDestructureUnused??0}}
async function invoke(raw,input,receiver){let value=raw.call(receiver,input,receiver);if(kind.includes('generator'))value=(await value.next()).value;else if(kind.includes('async'))value=await value;return value}
async function view(namespace){const raw=namespace.default;const held=await invoke(raw,argument('held'),raw);const detached=await invoke(raw,argument('detached'),undefined);return{namespace:shape(namespace),raw:shape(raw),name:raw.name,length:raw.length,functionTag:Object.prototype.toString.call(raw),prototype:shape(raw.prototype),prototypeConstructorSame:raw.prototype?raw.prototype.constructor===raw:null,dependency:shape(held[4]),dependencyRoot:held[4].root?shape(held[4].root):null,held:held.slice(0,4),detached:detached.slice(0,4)}}
function row(name,data){console.log('CJS-DESTRUCTURED:'+JSON.stringify({name,...data}));expect(data).toBeDefined()}
test('full namespace and dependency lifetime across reset',async()=>{vi.resetModules();const first=await import('./root.cjs');const cached=await import('./root.cjs');vi.resetModules();const second=await import('./root.cjs');vi.resetModules();const third=await import('./root.cjs');const values=[first,cached,second,third];const dependencies=await Promise.all(values.map(async x=>(await invoke(x.default,argument('dependency'),x.default))[4]));row('reset',{views:await Promise.all(values.map(view)),namespaces:matrix(values),raws:matrix(values.map(x=>x.default)),dependencies:matrix(dependencies),counts:counts()})})
test('actual helper shares actual namespace and reset ownership',async()=>{vi.resetModules();const first=await vi.importActual('./root.cjs');const ordinary=await import('./root.cjs');const again=await vi.importActual('./root.cjs');vi.resetModules();const second=await vi.importActual('./root.cjs');const later=await import('./root.cjs');const values=[first,ordinary,again,second,later];row('actual',{views:await Promise.all(values.map(view)),namespaces:matrix(values),raws:matrix(values.map(x=>x.default)),counts:counts()})})
test('held callable and dependency mutations survive fresh root reset',async()=>{vi.resetModules();const first=await import('./root.cjs');const held=first.default;const dependency=(await invoke(held,argument('dependency'),held))[4];held.extra={held:true};dependency.evaluation=731;const mutated=await view(first);vi.resetModules();const second=await import('./root.cjs');const freshDependency=(await invoke(second.default,argument('dependency'),second.default))[4];row('mutation',{held:await view(first),mutated,fresh:await view(second),sameExtra:held.extra===first.default.extra,freshHasExtra:'extra' in second.default,dependencySame:dependency===freshDependency,counts:counts()})})
test('native binding getter iterator close and original throw identity',async()=>{vi.resetModules();const {default:raw}=await import('./root.cjs');const events=[];let input;if(form==='object')input={get value(){events.push('get:value');return'parameter'}};else input={[Symbol.iterator](){events.push('iterator');return{next(){events.push('next');return{done:false,value:'parameter'}},return(){events.push('return');return{done:true}}}}};const output=await invoke(raw,input,raw);const sentinel=new Error('original parameter failure');const bad=form==='object'?{get value(){events.push('throw:get');throw sentinel}}:{[Symbol.iterator](){events.push('throw:iterator');return{next(){events.push('throw:next');throw sentinel}}}};let sameError=false;try{await invoke(raw,bad,raw)}catch(error){sameError=error===sentinel}let nullError;try{await invoke(raw,null,raw)}catch(error){nullError=error.name}row('parameter-effects',{events,output:output.slice(0,4),sameError,nullError});expect(sameError).toBe(true)})
test('native receiver local self and returned identity remain exact',async()=>{vi.resetModules();const first=await import('./root.cjs');const held=first.default;const heldSelf=await invoke(held,argument('self'),held);vi.resetModules();const second=await import('./root.cjs');const fresh=second.default;const freshSelf=await invoke(fresh,argument('self'),fresh);row('identity',{first:await view(first),second:await view(second),namedSelf:kind.startsWith('named-')?{held:heldSelf===held,heldStill:(await invoke(held,argument('self'),held))===held,fresh:freshSelf===fresh}:null,distinct:held!==fresh,counts:counts()})})
