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_LEAF_TLA:'+JSON.stringify({name,...value}));expect(value).toBeDefined()}

function deferred(){let resolve,reject;const promise=new Promise((yes,no)=>{resolve=yes;reject=no});return {promise,resolve,reject}}
function plan(events){const p={events,enter:deferred(),gate:deferred()};globalThis.__ws2GPlans.push(p);return p}
function clean(){vi.doUnmock('./unused.mjs');vi.doUnmock('./root.mjs');vi.resetModules();globalThis.__ws2GPlans=[];globalThis.__ws2GEvals=0}
const target=a=>({namespace:shape(a),value:a.value,object:a.object?.value,defaultValue:a.default?.value,defaultSame:a.default===a.object,read:a.read?.()});
test('registered and unregistered unused TLA targets stay lazy',()=>{clean();let calls=0;vi.doMock('./root.mjs',()=>{calls++;return {value:100}});vi.doUnmock('./root.mjs');row('unused',{calls,evaluations:globalThis.__ws2GEvals,plans:globalThis.__ws2GPlans.length})});
test('factory-only imports do not start the TLA original',async()=>{clean();let calls=0;vi.doMock('./root.mjs',()=>{calls++;return {value:100,object:{value:100},read(){return 100},default:null}});const a=await import('./root.mjs'),b=await import('./root.mjs');row('factory-only',{calls,evaluations:globalThis.__ws2GEvals,identity:a===b,a:target(a)})});
test('importOriginal shares a pending TLA source with overlapping public import',async()=>{clean();const events=[],original=plan(events);let calls=0;vi.doMock('./root.mjs',async importOriginal=>{calls++;events.push('factory-start');const a=await importOriginal();events.push('factory-complete');return {value:100,object:a.object,read:a.read,default:a.default}});const p=import('./root.mjs').then(a=>{events.push('p');return a});await original.enter.promise;const q=import('./root.mjs').then(a=>{events.push('q');return a});original.gate.resolve();const a=await p,b=await q,c=await import('./root.mjs');row('factory-original-overlap',{events,calls,evaluations:globalThis.__ws2GEvals,identity:same([a,b,c]),rows:[a,b,c].map(target),objects:same([a.object,b.object,c.object])})});
test('registration during a pending original preserves held original and observes final cache',async()=>{clean();const events=[],original=plan(events);const p=import('./root.mjs').then(a=>{events.push('old-public');return a});await original.enter.promise;let calls=0;vi.doMock('./root.mjs',()=>{calls++;events.push('factory');return {value:200,object:{value:200},read(){return 200},default:null}});const newer=await import('./root.mjs');events.push('new-public');original.gate.resolve();const old=await p,later=await import('./root.mjs');row('register-while-original-pending',{events,calls,evaluations:globalThis.__ws2GEvals,identity:same([old,newer,later]),rows:[old,newer,later].map(target)})});
test('reset while original is pending retains held namespace and creates a fresh generation',async()=>{clean();const events=[],oldPlan=plan(events);const p=import('./root.mjs').then(a=>{events.push('old-public');return a});await oldPlan.enter.promise;vi.resetModules();const newPlan=plan(events),q=import('./root.mjs').then(a=>{events.push('new-public');return a});await newPlan.enter.promise;oldPlan.gate.resolve();const old=await p;newPlan.gate.resolve();const fresh=await q,later=await import('./root.mjs');row('reset-while-original-pending',{events,evaluations:globalThis.__ws2GEvals,identity:same([old,fresh,later]),rows:[old,fresh,later].map(target),objects:same([old.object,fresh.object,later.object])})});
test('pending factory original fallback finishes through the real TLA before mocked completion',async()=>{clean();const events=[],original=plan(events),factoryEnter=deferred(),factoryGate=deferred();let calls=0;vi.doMock('./root.mjs',async()=>{calls++;events.push('factory-start');factoryEnter.resolve();await factoryGate.promise;events.push('factory-complete');return {value:300,object:{value:300},read(){return 300},default:null}});const p=import('./root.mjs').then(a=>{events.push('p');return a});await factoryEnter.promise;const q=import('./root.mjs').then(a=>{events.push('q');return a});await original.enter.promise;original.gate.resolve();const fallback=await q;factoryGate.resolve();const mocked=await p,later=await import('./root.mjs');row('pending-factory-fallback',{events,calls,evaluations:globalThis.__ws2GEvals,identity:same([fallback,mocked,later]),rows:[fallback,mocked,later].map(target)})});
test('TLA rejection through importOriginal retries factories and reset clears the original failure',async()=>{clean();const events=[],original=plan(events),raw=new SyntaxError('TLA original failure');let calls=0;vi.doMock('./root.mjs',async importOriginal=>{calls++;events.push('factory:'+calls);const a=await importOriginal();return {value:a.value,object:a.object,read:a.read,default:a.default}});const p=import('./root.mjs').catch(error=>error);await original.enter.promise;original.gate.reject(raw);const first=await p,second=await import('./root.mjs').catch(error=>error);const rejectedCalls=calls;vi.resetModules();const freshPlan=plan(events),q=import('./root.mjs');await freshPlan.enter.promise;freshPlan.gate.resolve();const fresh=await q;row('factory-original-rejection',{events,calls,rejectedCalls,evaluations:globalThis.__ws2GEvals,errors:[first,second].map(error=>failure(error,raw)),errorSame:first===second,causeSame:first?.cause===second?.cause,fresh:target(fresh)})});
test('unregister while a factory is pending preserves its held completion and selects original later',async()=>{clean();const events=[],original=plan(events),factoryEnter=deferred(),factoryGate=deferred();let calls=0;vi.doMock('./root.mjs',async()=>{calls++;events.push('factory-start');factoryEnter.resolve();await factoryGate.promise;events.push('factory-complete');return {value:400,object:{value:400},read(){return 400},default:null}});const p=import('./root.mjs').then(a=>{events.push('p');return a});await factoryEnter.promise;vi.doUnmock('./root.mjs');const q=import('./root.mjs').then(a=>{events.push('q');return a});await original.enter.promise;original.gate.resolve();const fallback=await q;factoryGate.resolve();const mocked=await p,later=await import('./root.mjs');row('unregister-while-factory-pending',{events,calls,evaluations:globalThis.__ws2GEvals,identity:same([fallback,mocked,later]),rows:[fallback,mocked,later].map(target)})});
