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 same=values=>values.map(value=>values.map(other=>value===other));
function failure(error,raw){return {shape:shape(error),name:error?.name,message:error?.message,rawSame:error===raw,causeSame:error?.cause===raw,cause:shape(error?.cause)}}
function row(name,value){console.log('WS2_ESM_NAMESPACE:'+JSON.stringify({name,...value}));expect(value).toBeDefined()}

function clean(){vi.doUnmock('./root.mjs');vi.doUnmock('././root.mjs');vi.doUnmock('./unused.mjs');vi.resetModules()}
test('ordinary namespaces retain complete order descriptors receiver and alias identity',async()=>{clean();const p=import('./root.mjs'),q=import('././root.mjs');const n=await p,a=await q,c=await import('./root.mjs'),unbound=n.read;row('ordinary-shape',{namespace:shape(n),root:shape(n.default),read:shape(n.read),identity:same([n,a,c]),differentPromises:p!==q,stateSame:n.state===n.alias&&n.alias===n.default,values:[n.evaluation,n.state.value],calls:[n.read('namespace'),unbound('unbound')],count:globalThis.__ws2FRoot})});
test('ordinary live bindings held values and reset generations retain exact identities',async()=>{clean();const n=await import('./root.mjs'),held=n.default,originalRead=n.read;const before={namespace:shape(n),root:shape(held),value:held.value};const next={value:99,token:{}};n.replace(next);const changed={namespace:shape(n),root:shape(n.default),value:n.state.value,stateSame:n.state===n.alias&&n.alias===n.default,nextSame:n.default===next,heldSame:n.default===held,heldValue:held.value,call:n.read('changed')};vi.resetModules();const fresh=await import('./root.mjs');row('ordinary-live-reset',{before,changed,after:{namespace:shape(fresh),root:shape(fresh.default),value:fresh.state.value,count:globalThis.__ws2FRoot},identity:same([n,fresh]),defaultIdentity:same([held,next,n.default,fresh.default]),readIdentity:originalRead===fresh.read,heldAfter:n.state.value})});
test('ordinary function errors and redefined namespace getters retain raw errors',async()=>{clean();const n=await import('./root.mjs'),raw=new SyntaxError('leaf namespace raw');let callError,getterError;try{n.fail(raw)}catch(error){callError=error};const before=shape(n);const value=n.alias;Object.defineProperty(n,'state',{get(){throw raw},enumerable:true,configurable:true});try{n.state}catch(error){getterError=error};row('ordinary-errors',{before,after:shape(n),default:shape(n.default),call:failure(callError,raw),getter:failure(getterError,raw),sameError:callError===getterError,unaffected:n.alias===value&&n.default===value,count:globalThis.__ws2FRoot})});
test('namespace certificate retention does not evaluate an unused target or factory',()=>{clean();let calls=0;vi.doMock('./unused.mjs',()=>{calls++;return {value:'mock'}});vi.doUnmock('./unused.mjs');row('ordinary-unused',{rootCount:globalThis.__ws2FRoot??0,unusedCount:globalThis.__ws2FUnused??0,factoryCalls:calls})});
