import {test,expect,vi} from 'vitest'
import {types} from 'node:util'
const counts=name=>[globalThis.__ws2Cross?.[name+'-root']??0,globalThis.__ws2Cross?.[name+'-peer']??0]
const errorRow=(error,cause)=>({message:error.message,name:error.name,causeSame:error.cause===cause,causeName:error.cause?.name,causeMessage:error.cause?.message,causeCauseSame:error.cause?.cause===cause,keys:Reflect.ownKeys(error).map(String),causeKeys:error.cause?Reflect.ownKeys(error.cause).map(String):[]})
const shape=namespace=>({keys:Reflect.ownKeys(namespace).map(key=>typeof key==='symbol'?String(key):key),prototypeNull:Object.getPrototypeOf(namespace)===null,objectPrototype:Object.getPrototypeOf(namespace)===Object.prototype,tag:Object.prototype.toString.call(namespace),brand:types.isModuleNamespaceObject(namespace),descriptors:Reflect.ownKeys(namespace).map(key=>{const d=Object.getOwnPropertyDescriptor(namespace,key);return [typeof key==='symbol'?String(key):key,{enumerable:d.enumerable,configurable:d.configurable,...('value'in d?{writable:d.writable,valueType:typeof d.value}:{get:typeof d.get,set:typeof d.set})}]})})
test('cold original evaluation starts an ordered dependency factory',async()=>{const events=[];let roots=0;let peers=0;vi.doMock('./cold/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {token:actual.token,peerToken:actual.peerToken,read:actual.read,evaluation:actual.evaluation}});vi.doMock('./cold/peer.mjs',()=>{events.push('peer-start');peers++;const token={kind:'mock-peer',count:8};return {token,read:()=>token.count,evaluation:73}}); const root=await import('./cold/target.mjs');const peer=await import('./cold/peer.mjs');console.log('WS2_CROSS_ORDER:'+JSON.stringify({name:'cold',events,calls:[roots,peers],values:root.read(),same:root.peerToken===peer.token,evaluations:counts('cold'),shapes:[shape(root),shape(peer)]}));expect(peers).toBe(1);expect(root.peerToken).toBe(peer.token)})
test('reverse original evaluation starts an ordered dependency factory',async()=>{const events=[];let roots=0;let peers=0;vi.doMock('./reverse/peer.mjs',()=>{events.push('peer-start');peers++;const token={kind:'mock-peer',count:8};return {token,read:()=>token.count,evaluation:73}});vi.doMock('./reverse/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {token:actual.token,peerToken:actual.peerToken,read:actual.read,evaluation:actual.evaluation}}); const root=await import('./reverse/target.mjs');const peer=await import('./reverse/peer.mjs');console.log('WS2_CROSS_ORDER:'+JSON.stringify({name:'reverse',events,calls:[roots,peers],values:root.read(),same:root.peerToken===peer.token,evaluations:counts('reverse'),shapes:[shape(root),shape(peer)]}));expect(peers).toBe(1);expect(root.peerToken).toBe(peer.token)})
test('pending dependency factory gates original target execution and overlaps its real original',async()=>{
 const events=[];let resolvePeer;let signalPeer;const started=new Promise(resolve=>signalPeer=resolve);let roots=0;let peers=0;vi.doMock('./pending/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {token:actual.token,peerToken:actual.peerToken,read:actual.read,evaluation:actual.evaluation}});vi.doMock('./pending/peer.mjs',async()=>{events.push('peer-start');peers++;signalPeer();const resolved=await new Promise(resolve=>resolvePeer=resolve);return {token:resolved.token,read:resolved.read,evaluation:resolved.evaluation}})
 const rootPending=import('./pending/target.mjs');await started;const before=counts('pending');const overlapPending=import('./pending/peer.mjs');events.push('overlap-requested');const token={kind:'mock-pending',count:9};resolvePeer({token,read:()=>token.count,evaluation:74});const root=await rootPending;const peerOverlap=await overlapPending;events.push('overlap-resolved');const peer=await import('./pending/peer.mjs');console.log('WS2_CROSS_PENDING:'+JSON.stringify({events,calls:[roots,peers],before,after:counts('pending'),same:[root.peerToken===peer.token,peerOverlap===peer,peerOverlap.token===peer.token],reads:[root.read(),peerOverlap.read(),peer.read()],shapes:[shape(root),shape(peerOverlap),shape(peer)]}));expect(root.peerToken).toBe(peer.token)
})
test('dependency rejection retries dependency and owner factories then retains successful exports',async()=>{
 const events=[];const cause=new Error('cross dependency failure');let failing=true;let roots=0;let peers=0;vi.doMock('./failure/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {token:actual.token,peerToken:actual.peerToken,read:actual.read,evaluation:actual.evaluation}});vi.doMock('./failure/peer.mjs',()=>{events.push('peer-start');peers++;if(failing)throw cause;const token={kind:'mock-recovered',count:11};return {token,read:()=>token.count,evaluation:75}})
 const first=await import('./failure/target.mjs').catch(error=>error);const second=await import('./failure/target.mjs').catch(error=>error);failing=false;const recovered=await import('./failure/target.mjs').catch(error=>error);const beforeDirect=[roots,peers];const peer=await import('./failure/peer.mjs').catch(error=>error);vi.resetModules();const afterReset=await import('./failure/target.mjs').catch(error=>error);console.log('WS2_CROSS_FAILURE:'+JSON.stringify({events,calls:[roots,peers],beforeDirect,errors:[errorRow(first,cause),errorRow(second,cause),errorRow(recovered,cause)],errorSame:[first===second,second===recovered],causeIdentity:[first.cause===second.cause,second.cause===recovered.cause],recoveredError:recovered instanceof Error,recoveredMessage:recovered.message,afterResetError:afterReset instanceof Error,values:[recovered.read?.(),afterReset.read?.()],same:[recovered.peerToken===peer.token,afterReset.peerToken===peer.token],evaluations:counts('failure'),shapes:[shape(recovered),shape(peer),shape(afterReset)]}));expect(first).toBeInstanceOf(Error)
})
test('held dependency results survive reset and unregister independently',async()=>{
 let roots=0;let peers=0;vi.doMock('./held/target.mjs',async original=>{roots++;const actual=await original();return {token:actual.token,peerToken:actual.peerToken,read:actual.read,evaluation:actual.evaluation}});vi.doMock('./held/peer.mjs',()=>{peers++;const token={kind:'mock-held',count:12};return {token,read:()=>token.count,evaluation:76}})
 const root=await import('./held/target.mjs');const peer=await import('./held/peer.mjs');vi.resetModules();const held=await import('./held/target.mjs');vi.doUnmock('./held/peer.mjs');const realPeer=await import('./held/peer.mjs');const stillHeld=await import('./held/target.mjs');vi.doUnmock('./held/target.mjs');const released=await import('./held/target.mjs');console.log('WS2_CROSS_HELD:'+JSON.stringify({calls:[roots,peers],identities:[root===held,root===stillHeld,root===released,root.peerToken===peer.token,released.peerToken===realPeer.token],reads:[root.read(),released.read()],evaluations:counts('held'),shapes:[shape(root),shape(released)]}));expect(root).toBe(held)
})
test('already loaded original dependencies are not reevaluated to start later registered factories',async()=>{
 const before=await import('./loaded/target.mjs');let roots=0;let peers=0;vi.doMock('./loaded/target.mjs',async original=>{roots++;const actual=await original();return {token:actual.token,peerToken:actual.peerToken,read:actual.read,evaluation:actual.evaluation}});vi.doMock('./loaded/peer.mjs',()=>{peers++;const token={kind:'mock-late',count:13};return {token,read:()=>token.count,evaluation:77}});const root=await import('./loaded/target.mjs');const peer=await import('./loaded/peer.mjs');console.log('WS2_CROSS_LOADED:'+JSON.stringify({calls:[roots,peers],identities:[root===before,root.token===before.token,root.peerToken===before.peerToken,root.peerToken===peer.token],reads:[before.read(),root.read(),peer.read()],evaluations:counts('loaded'),shapes:[shape(root),shape(before),shape(peer)]}));expect(roots).toBe(1)
})
test('unused cross-target registrations and reset evaluate no graph or factory',async()=>{let roots=0;let peers=0;vi.doMock('./unused/target.mjs',()=>{roots++;return {read:()=>31}});vi.doMock('./unused/peer.mjs',()=>{peers++;return {token:{count:32}}});vi.resetModules();vi.doUnmock('./unused/target.mjs');vi.doUnmock('./unused/peer.mjs');console.log('WS2_CROSS_UNUSED:'+JSON.stringify({calls:[roots,peers],evaluations:counts('unused')}));expect(roots+peers).toBe(0)})
test('mutually declared cycle factories retain pending original backedges',async()=>{
 const events=[];let roots=0;let peers=0;vi.doMock('./cycle/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {token:actual.token,peerToken:actual.peerToken,read:actual.read,getRoot:actual.getRoot,evaluation:actual.evaluation}});vi.doMock('./cycle/peer.mjs',async original=>{events.push('peer-start');peers++;const actual=await original();events.push('peer-original');const token={kind:'mock-cycle',count:14};return {token,read:()=>token.count,root:actual.root,evaluation:78}});const root=await import('./cycle/target.mjs');const peer=await import('./cycle/peer.mjs');console.log('WS2_CROSS_CYCLE:'+JSON.stringify({events,calls:[roots,peers],identities:[root.peerToken===peer.token,peer.root()===root.token],reads:[root.read(),peer.read()],evaluations:counts('cycle'),shapes:[shape(root),shape(peer)]}));expect(root.peerToken).toBe(peer.token)
})

test('unused static binding still demands a declared dependency factory when its owner evaluates',async()=>{const events=[];let roots=0;let peers=0;vi.doMock('./dead/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {value:actual.value}});vi.doMock('./dead/peer.mjs',()=>{events.push('peer-start');peers++;return {token:{count:27}}});const root=await import('./dead/target.mjs');const beforePeer={events:[...events],calls:[roots,peers]};const peer=await import('./dead/peer.mjs');console.log('WS2_CROSS_DEAD:'+JSON.stringify({beforePeer,events,calls:[roots,peers],values:[root.value,peer.token.count],shapes:[shape(root),shape(peer)]}));expect(root.value).toBe(91)})

test('a held first dependency reveals actual factory demand order for two static targets',async()=>{const events=[];let roots=0;let lefts=0;let rights=0;let release;let signal;const started=new Promise(resolve=>signal=resolve);vi.doMock('./fanout/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {left:actual.left,right:actual.right,read:actual.read}});vi.doMock('./fanout/left.mjs',async()=>{events.push('left-start');lefts++;signal();const resolved=await new Promise(resolve=>release=resolve);return {token:resolved.token}});vi.doMock('./fanout/right.mjs',()=>{events.push('right-start');rights++;return {token:{count:29}}});const pending=import('./fanout/target.mjs');await started;const before={events:[...events],calls:[roots,lefts,rights],rootEvaluations:counts('fanout')[0]};release({token:{count:28}});const root=await pending;const left=await import('./fanout/left.mjs');const right=await import('./fanout/right.mjs');console.log('WS2_CROSS_FANOUT:'+JSON.stringify({before,events,calls:[roots,lefts,rights],reads:root.read(),same:[root.left===left.token,root.right===right.token],evaluations:[counts('fanout')[0],globalThis.__ws2Cross?.['fanout-left']??0,globalThis.__ws2Cross?.['fanout-right']??0],shapes:[shape(root),shape(left),shape(right)]}));expect(roots).toBe(1)})

test('a declared cycle backedge remains live after an earlier held dependency await',async()=>{const events=[];let roots=0;let peers=0;let thirds=0;let release;let signal;const started=new Promise(resolve=>signal=resolve);vi.doMock('./async-cycle/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {token:actual.token,peerToken:actual.peerToken,getRoot:actual.getRoot,read:actual.read}});vi.doMock('./async-cycle/peer.mjs',async original=>{events.push('peer-start');peers++;const actual=await original();events.push('peer-original');return {token:{kind:'mock-peer',count:15},root:actual.root,read:actual.read}});vi.doMock('./async-cycle/third.mjs',async()=>{events.push('third-start');thirds++;signal();const resolved=await new Promise(resolve=>release=resolve);return {token:resolved.token}});const pending=import('./async-cycle/target.mjs');await started;const before={events:[...events],calls:[roots,peers,thirds],evaluations:counts('async-cycle')};release({token:{kind:'mock-third',count:16}});const root=await pending;const peer=await import('./async-cycle/peer.mjs');const third=await import('./async-cycle/third.mjs');console.log('WS2_CROSS_ASYNC_CYCLE:'+JSON.stringify({before,events,calls:[roots,peers,thirds],identities:[root.peerToken===peer.token,peer.root()===root.token],reads:[root.read(),peer.read(),third.token.count],evaluations:[...counts('async-cycle'),globalThis.__ws2Cross?.['async-cycle-third']??0],shapes:[shape(root),shape(peer),shape(third)]}));expect(peer.root()).toBe(root.token)})

test('a held mock dependency also gates a later ordinary dependency evaluation',async()=>{const events=[];let roots=0;let peers=0;let release;let signal;const started=new Promise(resolve=>signal=resolve);vi.doMock('./ordinary-after/target.mjs',async original=>{events.push('root-start');roots++;const actual=await original();events.push('root-original');return {token:actual.token,value:actual.value,read:actual.read}});vi.doMock('./ordinary-after/peer.mjs',async()=>{events.push('peer-start');peers++;signal();const resolved=await new Promise(resolve=>release=resolve);return {token:resolved.token}});const pending=import('./ordinary-after/target.mjs');await started;const before={events:[...events],calls:[roots,peers],ordinary:globalThis.__ws2Cross?.['ordinary-after-ordinary']??0,root:counts('ordinary-after')[0]};release({token:{count:17}});const root=await pending;console.log('WS2_CROSS_ORDINARY_AFTER:'+JSON.stringify({before,events,calls:[roots,peers],read:root.read(),evaluations:[counts('ordinary-after')[0],globalThis.__ws2Cross?.['ordinary-after-ordinary']??0],shape:shape(root)}));expect(root.value).toBe(93)})
