tricu

firefox-idle.mjs (12804B)

---

 // Real Firefox/WebDriver BiDi soak against the packaged page. No evaluator/UI mocks.
 // Each published/compiled session is left untouched in a genuinely hidden tab
 // for its entire requested interval; earlier checkpoints never rebuild later ones.
 import assert from 'node:assert/strict';
 import {spawn} from 'node:child_process';
 import {mkdtemp,rm,writeFile,realpath} from 'node:fs/promises';
 import {resolve} from 'node:path';
 import {startSiteServer} from './backend-server.mjs';
 
 const minutes=(process.env.IDLE_MINUTES??'10,20,30').split(',').map(Number);
 assert(minutes.length>0&&minutes.length<=6&&minutes.every(n=>Number.isFinite(n)&&n>0),'Positive IDLE_MINUTES, at most six checkpoints');
 const output=resolve(process.env.IDLE_REPORT??'/tmp/tricu-firefox-idle.json');
 const site=resolve(process.env.ARBORICX_SITE_ROOT??'result-site');
 const {server,url}=await startSiteServer(resolve(site,'runtime/haskell'));
 const profile=await mkdtemp('/tmp/tricu-firefox-idle-');
 const report={schema:2,started:new Date().toISOString(),site:await realpath(site),minutes,
   scope:'Headless Firefox on Linux; packaged page and both WASM/compiler bundles served by the existing loopback fixture server. Real inactive tabs, no page polling during idle. Each interval has independent published and compiled Haskell sessions. No OS suspend, memory-pressure injection, production network or extensions.',
   events:[],checkpoints:[],ok:false};
 let browser,socket,next=0,neutral,stderr='',failure;
 const pending=new Map();
 const pause=ms=>new Promise(r=>setTimeout(r,ms));
 const save=()=>writeFile(output,JSON.stringify(report,null,2)+'\n');
 function send(method,params={},timeout=90_000){
   const id=++next;
   return new Promise((resolve,reject)=>{
     const timer=setTimeout(()=>{pending.delete(id);reject(Error('BiDi timeout: '+method));},timeout);
     pending.set(id,{resolve,reject,timer});socket.send(JSON.stringify({id,method,params}));
   });
 }
 async function evaluate(context,expression){
   const reply=await send('script.evaluate',{target:{context},awaitPromise:true,
     expression:`Promise.resolve((${expression})).then(value=>JSON.stringify(value??null))`});
   if(reply.type!=='success')throw Error('Page evaluation: '+JSON.stringify(reply));
   return JSON.parse(reply.result.value);
 }
 const snapshot=context=>evaluate(context,`(()=>{
   const get=id=>document.getElementById(id);
   return {at:new Date().toISOString(),visibility:document.visibilityState,status:get('status')?.textContent,
     backend:'haskell-wasm',program:get('program-picker')?.value,
     sourceHidden:get('source-editor')?.hidden,sourceReadOnly:globalThis.__sourceEditor?.isReadOnly,
     sourceDisabled:globalThis.__sourceEditor?.isDisabled,source:globalThis.__sourceEditor?.getSource(),
     result:document.querySelector('.definition-card pre')?.textContent,
     diagnostic:get('compile-diagnostic')?.textContent,inspectionDisabled:document.querySelector('.definition-card select')?.disabled,
     errors:window.__idleErrors,visibilityChanges:window.__idleVisibility};
 })()`);
 async function wait(context,condition,label){
   const until=Date.now()+90_000;
   while(Date.now()<until){if(await evaluate(context,condition))return;await pause(50);}
   throw Error('Timeout '+label+': '+JSON.stringify(await snapshot(context)));
 }
 const status=(context,text)=>wait(context,`document.getElementById('status')?.textContent===${JSON.stringify(text)}`,text);
 const input=(context,id,value)=>evaluate(context,`(()=>{const e=document.getElementById(${JSON.stringify(id)});if(${JSON.stringify(id)}==='source-editor'){globalThis.__sourceEditor.replaceSource(${JSON.stringify(value)},true);}else{e.value=${JSON.stringify(value)};e.dispatchEvent(new Event('input'));}})()`);
 const change=(context,id,value)=>evaluate(context,`(()=>{const e=document.getElementById(${JSON.stringify(id)});e.value=${JSON.stringify(value)};e.dispatchEvent(new Event('change'));})()`);
 const click=(context,id)=>evaluate(context,`document.getElementById(${JSON.stringify(id)}).click()`);
 async function editable(context){
   const state=await snapshot(context);
   assert.equal(state.sourceHidden,false,JSON.stringify(state));
   assert.equal(state.sourceReadOnly,false,JSON.stringify(state));
   assert.equal(state.sourceDisabled,false,JSON.stringify(state));
   assert.deepEqual(state.errors??[],[],JSON.stringify(state));
   return state;
 }
 async function run(context,expression,expected,codec='number'){
   const actual=await evaluate(context,`(async()=>{
     const close=document.querySelector('.definition-card [aria-label="Close definition inspection"]');
     if(!document.querySelector('.definition-card').hidden)close.click();
     const helper=await import('/source-probe-helpers.mjs');return helper.evaluateSource(${JSON.stringify(expression)},${JSON.stringify(codec)});
   })()`);
   assert.equal(actual,expected,expression);await editable(context);
 }
 async function select(context,name){await change(context,'program-picker','demo:'+name);await status(context,'Ready');await editable(context);}
 async function exercise(job){
   const {context,mode}=job;
   job.resumedAt=new Date().toISOString();job.idleSeconds=(Date.now()-job.backgroundAt)/1000;
   job.before=await snapshot(context);
   assert.equal(job.before.visibility,'hidden','Tab remained inactive before resuming');
   assert(job.idleSeconds>=job.minutes*60,'Complete idle interval');
   assert.equal(job.before.visibilityChanges.filter(e=>e.visibility==='visible').length,0,'No accidental activation during idle');
   await send('browsingContext.activate',{context});
   assert.equal(await evaluate(context,'document.visibilityState'),'visible','Real foreground transition');
   await editable(context);
   // First operation uses the original retained session, before any replacement.
   await run(context,'answer',mode==='compiled'?'43':'42');
   for(let cycle=0;cycle<2;cycle++){
     await select(context,'arithmetic');await run(context,'total','12');
     const source=await evaluate(context,"globalThis.__sourceEditor.getSource()");
     assert(source.includes('Math.add 5 7'),'Known independently checked arithmetic specimen');
     await input(context,'source-editor',source.replace('Math.add 5 7','Math.add 8 9'));
     await status(context,'Compiled');await run(context,'total','17');
     await click(context,'restore-source');await status(context,'Ready');await run(context,'total','12');
     await select(context,'functions');await run(context,'double 6','12');
     await select(context,'language-reference');await run(context,'identity 23','23');
   }
   // Ordinary diagnostics must not strand the published/draft editor read-only.
   await evaluate(context,"import('/source-probe-helpers.mjs').then(helper=>helper.inspect('probeResult','string'))");
   assert((await evaluate(context,"document.querySelector('.definition-card [role=status]').textContent")).includes('Cannot interpret'));
   await editable(context);
   await run(context,'identity 24','24');
   await input(context,'source-editor','!export answer\nanswer = (');await status(context,'Compilation failed');await editable(context);
   await click(context,'restore-source');await status(context,'Ready');await run(context,'identity 25','25');
   job.after=await snapshot(context);job.ok=true;
   console.log(`PASS ${job.minutes} min ${mode}: ${job.idleSeconds.toFixed(1)}s hidden; retained inspection, switching, compilation, restoration and diagnostic recovery`);
   await send('browsingContext.activate',{context:neutral});
   await send('browsingContext.close',{context});
   await save();
 }
 try{
   browser=spawn(process.argv[2]??'firefox',['--headless','--no-remote','--new-instance','--remote-debugging-port','0','--profile',profile,'about:blank'],{
     stdio:['ignore','ignore','pipe'],env:{...process.env,HOME:profile,XDG_CONFIG_HOME:resolve(profile,'config'),XDG_CACHE_HOME:resolve(profile,'cache'),XDG_DATA_HOME:resolve(profile,'data'),MOZ_CRASHREPORTER_DISABLE:'1',GSETTINGS_BACKEND:'memory'},
   });
   const endpoint=await new Promise((resolve,reject)=>{
     const timer=setTimeout(()=>reject(Error('Firefox BiDi startup: '+stderr)),20_000);
     browser.on('error',error=>{clearTimeout(timer);reject(error);});
     browser.on('exit',code=>{clearTimeout(timer);reject(Error('Firefox exited '+code));});
     browser.stderr.on('data',chunk=>{stderr=(stderr+chunk).slice(-32_000);const match=stderr.match(/WebDriver BiDi listening on (ws:\/\/[^\s]+)/);if(match){clearTimeout(timer);resolve(match[1]);}});
   });
   socket=new WebSocket(endpoint+'/session');await new Promise((r,j)=>{socket.onopen=r;socket.onerror=j;});
   socket.onmessage=({data})=>{
     const message=JSON.parse(data);
     if(message.id){const waiter=pending.get(message.id);if(!waiter)return;clearTimeout(waiter.timer);pending.delete(message.id);
       if(message.type==='error')waiter.reject(Error(JSON.stringify(message)));else waiter.resolve(message.result);
     }else if((message.method==='log.entryAdded'&&message.params.level==='error')||message.method==='network.fetchError'||(message.method==='network.responseCompleted'&&message.params.response.status>=400)){
       report.events.push({at:new Date().toISOString(),...message});
     }
   };
   const session=await send('session.new',{capabilities:{}});report.capabilities=session.capabilities;
   await send('session.subscribe',{events:['log.entryAdded','network.fetchError','network.responseCompleted']});
   neutral=(await send('browsingContext.getTree')).contexts[0].context;
   for(const interval of minutes)for(const mode of ['published','compiled']){
     const context=(await send('browsingContext.create',{type:'tab',background:true})).context;
     await send('browsingContext.activate',{context});
     await send('browsingContext.navigate',{context,url,wait:'complete'});
     await evaluate(context,`(()=>{
       window.__idleErrors=[];window.__idleVisibility=[];
       window.addEventListener('error',event=>window.__idleErrors.push({type:'error',message:event.message,filename:event.filename,line:event.lineno}));
       window.addEventListener('unhandledrejection',event=>window.__idleErrors.push({type:'rejection',message:String(event.reason)}));
       document.addEventListener('visibilitychange',()=>window.__idleVisibility.push({visibility:document.visibilityState,at:Date.now()}));
     })()`);
     await status(context,'Ready');await evaluate(context,"import('/source-probe-helpers.mjs').then(()=>true)");
     if(mode==='compiled'){
       const source=await evaluate(context,"globalThis.__sourceEditor.getSource()");
       assert(source.includes('answer = 42'));await input(context,'source-editor',source.replace('answer = 42','answer = 43'));
       await status(context,'Compiled');
     }
     await run(context,'answer',mode==='compiled'?'43':'42');
     const job={context,mode,minutes:interval};report.checkpoints.push(job);
     await send('browsingContext.activate',{context:neutral});
   }
   // Start all independent intervals only after every session has been warmed.
   for(const job of report.checkpoints){
     assert.equal(await evaluate(job.context,'document.visibilityState'),'hidden');
     await evaluate(job.context,'window.__idleVisibility=[]');job.backgroundAt=Date.now();
   }
   await save();console.log(`Warmed ${report.checkpoints.length} independent Haskell sessions in Firefox ${report.capabilities.browserVersion}. Background waits: ${minutes.join(', ')} minutes.`);
   for(const job of [...report.checkpoints].sort((a,b)=>a.backgroundAt+a.minutes*60_000-b.backgroundAt-b.minutes*60_000)){
     await pause(Math.max(0,job.backgroundAt+job.minutes*60_000-Date.now()));
     try{await exercise(job);}catch(error){job.error=String(error);try{job.failureState=await snapshot(job.context);}catch(capture){job.captureError=String(capture);}
       try{const shot=await send('browsingContext.captureScreenshot',{context:job.context});await writeFile(output+'.failure.png',Buffer.from(shot.data,'base64'));}catch{}
       throw error;
     }
   }
   assert.deepEqual(report.events,[],'Unexpected browser console/network errors');
   report.ok=true;
 }catch(error){failure=error;report.error=error.stack??String(error);}
 finally{
   report.finished=new Date().toISOString();report.stderr=stderr;await save();
   if(socket?.readyState===WebSocket.OPEN){try{await send('browser.close',{},5000);}catch{}socket.close();}
   if(browser?.exitCode===null&&browser.signalCode===null){const exited=new Promise(r=>browser.once('exit',r));browser.kill('SIGKILL');await exited;}
   for(const waiter of pending.values()){clearTimeout(waiter.timer);waiter.reject(Error('Browser closed'));}pending.clear();
   server.closeAllConnections();await new Promise(r=>server.close(r));
   await rm(profile,{recursive:true,force:true,maxRetries:5,retryDelay:100});
 }
 if(failure)throw failure;
 console.log(`PASS Firefox idle soak. Report: ${output}`);