import {test,expect,vi} from 'vitest'
import {types} from 'node:util'
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}})}
}

const kind="async-generator"
function failure(fn){try{fn();return null}catch(error){return {name:error.name,message:error.message}}}
async function consume(value){if(value&&typeof value.next==='function'){const first=await value.next();const last=first.done?null:await value.next();return {type:Object.prototype.toString.call(value),first,last,promise:false}}return {type:Object.prototype.toString.call(value),first:{value:await value,done:true},last:null,promise:types.isPromise(value)}}
async function view(namespace){const raw=namespace.default;const result=await consume(raw.call(raw,'held',raw,3,4));const dependency=result.first.value[5];const detached=await consume(raw('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(dependency),dependencyRoot:dependency.root?shape(dependency.root):null,call:{...result,first:{...result.first,value:result.first.value.slice(0,5)}},detached:{...detached,first:{...detached.first,value:detached.first.value.slice(0,5)}},constructFailure:failure(()=>new raw())}}
function same(values){return values.map(value=>values.map(other=>value===other))}
function counts(){return {root:globalThis.__nextKindRoot??0,dependency:globalThis.__nextKindDependency??0,unused:globalThis.__nextKindUnused??0}}
function row(name,data){console.log('WS2_CJS_FUNCTION_KINDS:'+JSON.stringify({name,kind,...data}));expect(data).toBeDefined()}
test('complete async or generator namespace and dependency lifetime across resets',async()=>{
vi.resetModules();const first=await import('./root.cjs'),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=[];for(const value of values)dependencies.push((await consume(value.default.call(value.default,'dependency',value.default))).first.value[5]);row('reset',{views:await Promise.all(values.map(view)),identities:same(values),rawIdentities:same(values.map(value=>value.default)),dependencyIdentities:same(dependencies),counts:counts()});expect(counts().unused).toBe(0)
})
test('actual helper retains exact async or generator namespace reset ownership',async()=>{
vi.resetModules();const first=await vi.importActual('./root.cjs'),ordinary=await import('./root.cjs'),again=await vi.importActual('./root.cjs');vi.resetModules();const second=await vi.importActual('./root.cjs'),later=await import('./root.cjs');const values=[first,ordinary,again,second,later];row('actual',{views:await Promise.all(values.map(view)),identities:same(values),rawIdentities:same(values.map(value=>value.default)),counts:counts()})
})
test('held async or generator defaults and dependency mutations stay live',async()=>{
vi.resetModules();const first=await import('./root.cjs'),raw=first.default;const dependency=(await consume(raw.call(raw,'dependency',raw))).first.value[5];raw.extra={held:true};dependency.evaluation=731;const mutated=await view(first);vi.resetModules();const second=await import('./root.cjs');const secondDependency=(await consume(second.default.call(second.default,'dependency',second.default))).first.value[5];row('mutation',{held:await view(first),mutated,fresh:await view(second),heldExtraSame:raw.extra===first.default.extra,freshHasExtra:'extra'in second.default,dependencySame:dependency===secondDependency,counts:counts()})
})
test('local self and outstanding operations retain their actual old function',async()=>{
vi.resetModules();const first=await import('./root.cjs'),held=first.default,operation=held.call(held,undefined,held,7,8);vi.resetModules();const second=await import('./root.cjs'),fresh=second.default;const heldSelf=(await consume(held.call(held,'self',held))).first.value;const freshSelf=(await consume(fresh.call(fresh,'self',fresh))).first.value;const continued=await consume(operation);row('self-operation',{heldSelf:heldSelf===held,freshSelf:freshSelf===fresh,distinct:held!==fresh,continued:{...continued,first:{...continued.first,value:continued.first.value.slice(0,5)}},first:await view(first),second:await view(second),counts:counts()});expect(heldSelf).toBe(held);expect(freshSelf).toBe(fresh);expect(fresh).not.toBe(held)
})
test('native rejection or generator throw retains its actual error and cause',async()=>{
vi.resetModules();const namespace=await import('./root.cjs'),raw=namespace.default;let failure,throwIdentity=null;try{await consume(raw.call(raw,'throws',raw))}catch(error){failure={name:error.name,message:error.message,cause:error.cause}}if(kind!=='async'){const operation=raw.call(raw,'first',raw);await operation.next();const original=new Error('same iterator throw');try{await operation.throw(original)}catch(error){throwIdentity=error===original}}row('errors',{failure,throwIdentity,counts:counts()});expect(failure.name).toBe('Error');expect(failure.cause).toBe('actual cause');expect(kind==='async'||throwIdentity).toBe(true)
})
