buninu-browser 0.2.4 → 0.4.0

package/test/qml-flea-backend.test.js

@@ -0,0 +1,78 @@
+// Opt-in integration: unmodified packaged QML and the real installed Flea binary.
+import { test, expect } from 'bun:test';
+import { join } from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { createBrowser } from '../lib/headless-shell.js';
+import { fleaSandbox } from './helpers/flea-sandbox.js';
+const root = process.env.BUNINU_FLEA_ROOT,
+  omarchy = process.env.BUNINU_OMARCHY_ROOT,
+  binary = process.env.FLEA_BIN;
+test.skipIf(!root || !omarchy || !binary)(
+  'official backend lists real files, receives navigation and refreshes directory changes',
+  async () => {
+    const sandbox = fleaSandbox(root, omarchy),
+      oldPath = process.env.FLEA_PATH;
+    const home = sandbox.values.HOME,
+      folder = join(home, 'Documents');
+    mkdirSync(folder);
+    writeFileSync(join(home, 'hello.txt'), 'hello');
+    writeFileSync(join(folder, 'inside.txt'), 'inside');
+    process.env.FLEA_PATH = home;
+    let browser;
+    try {
+      browser = await createBrowser({
+        spareRenderer: false,
+        rendererTimeout: 30000,
+      });
+      await browser.context.addInitScript(
+        `globalThis.qmlErrors=[];addEventListener('error',e=>qmlErrors.push(String(e.error?.stack||e.message)));const original=console.error;console.error=(...args)=>{qmlErrors.push(args.map(String).join(' '));original(...args);};`,
+      );
+      await browser.context.navigate(
+        Bun.pathToFileURL(join(sandbox.flea, 'ui/boot/shell.qml')).href,
+      );
+      const text = () => browser.context.evaluate('document.body.innerText');
+      const until = async (predicate) => {
+        for (let n = 0; n < 150; n++) {
+          if (await predicate()) return;
+          await Bun.sleep(40);
+        }
+        throw Error('Flea did not settle: ' + (await text()));
+      };
+      await until(async () => (await text()).includes('hello.txt'));
+      writeFileSync(join(home, 'added.txt'), 'watch update');
+      await until(async () => (await text()).includes('added.txt'));
+      await browser.context.press('l', { code: 'KeyL', modifiers: 2 });
+      await until(
+        async () =>
+          await browser.context.evaluate(
+            'document.activeElement?.tagName==="INPUT"',
+          ),
+      );
+      await browser.context.type(folder);
+      await browser.context.press('Enter', { code: 'Enter' });
+      await until(
+        async () =>
+          (await text()).includes('inside.txt') &&
+          !(await text()).includes('hello.txt'),
+      );
+      await Bun.write(
+        '/tmp/buninu-flea-official-backend.png',
+        Buffer.from(
+          await browser.context.screenshot({ format: 'png' }),
+          'base64',
+        ),
+      );
+      // Wait through the upstream prebuild driver's first idle tick too.
+      await Bun.sleep(1500);
+      expect(await browser.context.evaluate('JSON.stringify(qmlErrors)')).toBe(
+        '[]',
+      );
+    } finally {
+      browser?.close();
+      if (oldPath === undefined) delete process.env.FLEA_PATH;
+      else process.env.FLEA_PATH = oldPath;
+      sandbox.close();
+    }
+  },
+  60000,
+);

package/test/qml-flea-columns-backend.test.js

@@ -0,0 +1,38 @@
+import { test, expect } from 'bun:test';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createBrowser } from '../lib/headless-shell.js';
+import { fleaSandbox } from './helpers/flea-sandbox.js';
+const flea=process.env.BUNINU_FLEA_ROOT, omarchy=process.env.BUNINU_OMARCHY_ROOT;
+test.skipIf(!flea||!omarchy||!process.env.FLEA_BIN)('Flea initially shows language-marked files and retains rows after repeated pooling',async()=>{
+ const sandbox=fleaSandbox(flea,omarchy), oldPath=process.env.FLEA_PATH;
+ let browser;
+ try {
+  process.env.FLEA_PATH=sandbox.values.HOME;
+  mkdirSync(join(sandbox.values.HOME,'Documents'));
+  await Bun.write(join(sandbox.values.HOME,'Documents/inside.txt'),'inside');
+  await Bun.write(join(sandbox.values.HOME,'hello.md'),'hello');
+  await Bun.write(join(sandbox.values.HOME,'second.js'),'second');
+  browser=await createBrowser({spareRenderer:false,rendererTimeout:30000});
+  await browser.context.resize(800,600);
+  await browser.context.addInitScript(`globalThis.qmlErrors=[];addEventListener('error',e=>qmlErrors.push(String(e.error?.stack||e.message)));`);
+  await browser.context.navigate(Bun.pathToFileURL(join(sandbox.flea,'ui/boot/shell.qml')).href);
+  const names=column=>browser.context.evaluate(`Array.from(document.querySelectorAll('[data-qml-type="Text"]')).map(e=>({text:e.textContent,r:e.getBoundingClientRect()})).filter(({text,r})=>/^(cache|config|data|home|imports|state|Documents|inside.txt|hello.md|second.js)$/.test(text)&&r.width>0&&r.y>20&&r.x>=${column===0?200:500}&&r.x<${column===0?500:800}).sort((a,b)=>a.r.y-b.r.y).map(e=>e.text)`);
+  async function until(column,wanted){for(let i=0;i<150;i++){const actual=await names(column);if(JSON.stringify(actual)===JSON.stringify(wanted))return;await Bun.sleep(30);}expect(await names(column)).toEqual(wanted);}
+  const key=k=>browser.context.press(k,{code:k});
+  await until(0,['Documents','hello.md','second.js']);
+  await browser.context.press('2',{code:'Digit2',modifiers:2});
+  await until(1,['inside.txt']);
+  for(let i=0;i<4;i++){
+   await key('ArrowRight');await until(0,['inside.txt']);
+   await key('ArrowLeft');await until(0,['Documents','hello.md','second.js']);
+  }
+  await key('ArrowLeft');
+  const parent=['cache','config','data','home','imports','state'];
+  await until(0,parent);await until(1,['Documents','hello.md','second.js']);
+  await key('ArrowUp');await until(1,[]);expect(await names(0)).toEqual(parent);
+  await key('ArrowDown');await until(1,['Documents','hello.md','second.js']);expect(await names(0)).toEqual(parent);
+  await Bun.write('/tmp/flea-columns-fixed.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+  expect(await browser.context.evaluate('qmlErrors')).toEqual([]);
+ }finally{browser?.close();if(oldPath===undefined)delete process.env.FLEA_PATH;else process.env.FLEA_PATH=oldPath;sandbox.close();}
+},60000);

package/test/qml-flea-compile.test.js

@@ -0,0 +1,78 @@
+// Coverage inventory against unchanged sources. Compilation is not a runtime claim.
+import { test, expect } from 'bun:test';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadQmlGraphSync } from '../lib/qml/loader.js';
+import { createQmlDocument } from '../lib/qml/document.js';
+import { parseQml } from '../lib/qml/parser.js';
+import { fleaSandbox } from './helpers/flea-sandbox.js';
+const flea = process.env.BUNINU_FLEA_ROOT,
+  omarchy = process.env.BUNINU_OMARCHY_ROOT;
+test.skipIf(!flea || !omarchy)(
+  'Flea source inventory parses every QML file and reports known unsupported modules',
+  () => {
+    const sandbox = fleaSandbox(flea, omarchy);
+    try {
+      const dir = join(sandbox.flea, 'ui');
+      let parsed = 0,
+        compiled = 0;
+      const blocked = [];
+      const parseDirectory = (path) => {
+        for (const entry of readdirSync(path, { withFileTypes: true })) {
+          const file = join(path, entry.name);
+          if (entry.isDirectory()) parseDirectory(file);
+          else if (entry.name.endsWith('.qml')) {
+            parseQml(readFileSync(file, 'utf8'));
+            parsed++;
+          }
+        }
+      };
+      parseDirectory(dir);
+      for (const name of readdirSync(dir).filter((name) =>
+        name.endsWith('.qml'),
+      )) {
+        const file = join(dir, name),
+          url = Bun.pathToFileURL(file).href,
+          source = readFileSync(file, 'utf8');
+        try {
+          const graph = loadQmlGraphSync(
+            source,
+            url,
+            (href) => ({ body: readFileSync(new URL(href)) }),
+            {
+              importRoots: [
+                Bun.pathToFileURL(sandbox.values.QML_IMPORT_PATH + '/').href,
+              ],
+            },
+          );
+          const result = createQmlDocument(source, url, {
+            graph,
+            component: true,
+          });
+          const error = result.document.querySelector('p')?.textContent;
+          if (error) throw Error(error);
+          compiled++;
+        } catch (error) {
+          blocked.push([name, error.message]);
+        }
+      }
+      const expected = {
+        PdfViewer: 'QtQuick.Pdf',
+        PreviewPdf: 'QtQuick.Pdf',
+        PreviewAnimation: 'AnimatedImage',
+      };
+      for (const [file, message] of blocked) {
+        expect(expected[file.slice(0, -4)]).toBeDefined();
+        expect(message).toContain(expected[file.slice(0, -4)]);
+      }
+      expect(parsed).toBeGreaterThanOrEqual(239);
+      expect(compiled).toBeGreaterThanOrEqual(231);
+      console.log(
+        `Flea: ${parsed} QML parsed; ${compiled} top-level components compiled; ${blocked.length} explicitly blocked. This is not full runtime coverage.`,
+      );
+    } finally {
+      sandbox.close();
+    }
+  },
+  60000,
+);

package/test/qml-flea-launcher.test.js

@@ -0,0 +1,88 @@
+// Actual official executable -> PATH qs wrapper -> browser -> wl_shm on own Land.
+import { test, expect } from 'bun:test';
+import { join, resolve } from 'node:path';
+import { mkdirSync, symlinkSync, writeFileSync } from 'node:fs';
+import { fleaSandbox } from './helpers/flea-sandbox.js';
+const root = process.env.BUNINU_FLEA_ROOT,
+  omarchy = process.env.BUNINU_OMARCHY_ROOT,
+  binary = process.env.FLEA_BIN;
+test.skipIf(
+  !root || !omarchy || !binary || !process.env.BUNINU_QML_WAYLAND_TEST,
+)(
+  'official Flea executable starts our qs wrapper and closes through Wayland',
+  async () => {
+    const { start } = await import('../../buninu-land/compositor.js');
+    const sandbox = fleaSandbox(root, omarchy),
+      previous = process.env.XDG_RUNTIME_DIR;
+    let land, child, logs;
+    try {
+      const wrapperDir = join(sandbox.dir, 'bin');
+      mkdirSync(wrapperDir);
+      symlinkSync(resolve('lib/qml/qswayland'), join(wrapperDir, 'qs'));
+      mkdirSync(join(sandbox.values.HOME, 'Documents'));
+      writeFileSync(join(sandbox.values.HOME, 'hello.txt'), 'hello');
+      process.env.XDG_RUNTIME_DIR = sandbox.dir;
+      land = await start([
+        '--remote-debugging-port=0',
+        '--window-size=900,600',
+      ]);
+      child = Bun.spawn([resolve(binary), '--gui', sandbox.values.HOME], {
+        env: {
+          ...process.env,
+          PATH: wrapperDir + ':' + process.env.PATH,
+          FLEA_UI: join(sandbox.flea, 'ui'),
+          WAYLAND_DISPLAY: 'wayland-buninu',
+          QSG_RHI_BACKEND: 'software',
+        },
+        stdout: 'pipe',
+        stderr: 'pipe',
+      });
+      logs = Promise.all([
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+      ]);
+      const until = async (fn) => {
+        for (let n = 0; n < 500; n++) {
+          if (await fn()) return;
+          if (child.exitCode !== null)
+            throw Error('Flea exited: ' + (await logs).join('\n'));
+          await Bun.sleep(40);
+        }
+        throw Error('Flea wrapper did not settle');
+      };
+      await until(() =>
+        land.compositor.wm.renderSurfaces().some((s) => s.pixels),
+      );
+      await Bun.sleep(4000);
+      const surfaces = land.compositor.wm
+        .renderSurfaces()
+        .filter((s) => s.pixels);
+      expect(surfaces.length).toBeGreaterThan(0);
+      await Bun.write(
+        '/tmp/buninu-flea-official-launcher.png',
+        Buffer.from(await land.context.screenshot({ format: 'png' }), 'base64'),
+      );
+      for (const type of ['keyDown', 'keyUp'])
+        land.context.dispatchKeyEvent({
+          type,
+          key: 'w',
+          code: 'KeyW',
+          modifiers: 4,
+        });
+      await until(() => child.exitCode !== null);
+      expect(await child.exited).toBe(0);
+      const output = (await logs).join('\n');
+      expect(output).not.toMatch(
+        /page error:|QML Loader:|QML createObject:|Wayland frontend:/,
+      );
+    } finally {
+      child?.kill();
+      if (child) await child.exited;
+      land?.close();
+      if (previous === undefined) delete process.env.XDG_RUNTIME_DIR;
+      else process.env.XDG_RUNTIME_DIR = previous;
+      sandbox.close();
+    }
+  },
+  60000,
+);

package/test/qml-flea-markdown-backend.test.js

@@ -0,0 +1,31 @@
+import {test,expect} from 'bun:test';
+import {join} from 'node:path';
+import {createBrowser} from '../lib/headless-shell.js';
+import {fleaSandbox} from './helpers/flea-sandbox.js';
+const flea=process.env.BUNINU_FLEA_ROOT,omarchy=process.env.BUNINU_OMARCHY_ROOT;
+test.skipIf(!flea||!omarchy||!process.env.FLEA_BIN)('Flea Markdown preview stacks unequal blocks without overlap after scrolling and resizing',async()=>{
+ const sandbox=fleaSandbox(flea,omarchy),oldPath=process.env.FLEA_PATH;let browser;
+ try{
+  process.env.FLEA_PATH=sandbox.values.HOME;
+  const sections=Array.from({length:8},(_,i)=>`## Section ${i}\n\n${'A paragraph with enough words to wrap. '.repeat(i+2)}\n\n\`\`\`\n${'a code line\n'.repeat(i+1)}\`\`\`\n`);
+  await Bun.write(join(sandbox.values.HOME,'document.md'),'# Markdown preview\n\n'+sections.join('\n'));
+  browser=await createBrowser({spareRenderer:false,rendererTimeout:30000});await browser.context.resize(800,600);
+  await browser.context.addInitScript(`globalThis.issues=[];addEventListener('unhandledrejection',e=>issues.push(String(e.reason?.stack||e.reason)));globalThis.views=[];let runtime;Object.defineProperty(globalThis,'__qmlRuntime',{get:()=>runtime,set:r=>{runtime=r;const d=r.describe;r.describe=(v,t,...a)=>{if(t.includes('ListView'))views.push(v);return d(v,t,...a)}}});`);
+  await browser.context.navigate(Bun.pathToFileURL(join(sandbox.flea,'ui/boot/shell.qml')).href);
+  const run=s=>browser.context.evaluate(s);
+  async function until(fn){for(let i=0;i<180;i++){if(await fn())return;await Bun.sleep(30);}throw Error('Markdown preview did not settle');}
+  await until(async()=>(await run('document.body.innerText')).includes('document.md'));
+  await browser.context.press(' ',{code:'Space'});
+  const view=`views.find(v=>v.count>0&&Array.from({length:v.count},(_,i)=>v.itemAtIndex(i)).some(c=>c?.block?.type))`;
+  await until(async()=>await run(`!!(${view})`));
+  const read=()=>run(`(()=>{const v=${view};return Array.from({length:v.count},(_,i)=>v.itemAtIndex(i)).filter(Boolean).map(c=>({i:c.blockIndex,y:c.y,h:c.height})).sort((a,b)=>a.i-b.i)})()`);
+  const separated=rows=>rows.length>2&&rows.every((row,i)=>row.h>0&&(!i||row.y>=rows[i-1].y+rows[i-1].h));
+  await until(async()=>separated(await read()));expect(separated(await read())).toBe(true);
+  await run(`(${view}).contentY=650`);await until(async()=>separated(await read()));
+  expect(separated(await read())).toBe(true);
+  await browser.context.resize(600,600);await until(async()=>separated(await read()));
+  expect(separated(await read())).toBe(true);
+  expect(await run('issues')).toEqual([]);
+  await Bun.write('/tmp/flea-markdown-layout.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+ }finally{browser?.close();if(oldPath===undefined)delete process.env.FLEA_PATH;else process.env.FLEA_PATH=oldPath;sandbox.close();}
+},60000);

package/test/qml-flea-media.test.js

@@ -0,0 +1,28 @@
+import {test,expect} from 'bun:test';
+import {join} from 'node:path';
+import {createBrowser} from '../lib/headless-shell.js';
+import {fleaSandbox} from './helpers/flea-sandbox.js';
+const root=process.env.BUNINU_FLEA_ROOT,omarchy=process.env.BUNINU_OMARCHY_ROOT;
+test.skipIf(!root||!omarchy)('unchanged Flea PreviewMedia loads MP4 and MP3 through the shared player',async()=>{
+ const sandbox=fleaSandbox(root,omarchy);let browser;
+ try{
+  const video=Bun.pathToFileURL(join(import.meta.dir,'fixtures/long-video.mp4')).href;
+  const audio=Bun.pathToFileURL(join(import.meta.dir,'fixtures/tone.mp3')).href;
+  const file=join(sandbox.dir,'main.qml');
+  await Bun.write(file,`import QtQuick
+import ${JSON.stringify(join(root,'ui'))} as Flea
+Flea.PreviewMedia {id:preview;width:640;height:360;kind:"video";autoStart:false;path:${JSON.stringify(Bun.fileURLToPath(video))}}`);
+  browser=await createBrowser({spareRenderer:false});
+  await browser.context.addInitScript(`globalThis.players=[];let rt;Object.defineProperty(globalThis,'__qmlRuntime',{get:()=>rt,set:r=>{rt=r;const d=r.describe;r.describe=(v,t,...a)=>{if(t.includes('MediaPlayer'))players.push(v);return d(v,t,...a)}}});`);
+  await browser.context.navigate(Bun.pathToFileURL(file).href);
+  const run=s=>browser.context.evaluate(s);
+  async function until(code){for(let i=0;i<200;i++){if(await run(code))return;await Bun.sleep(30)}throw Error(await run('document.body.innerText'));}
+  await until('players[0]?.duration>1000');
+  expect(await run('players[0].hasVideo')).toBe(true);
+  expect(await run('players[0].error')).toBe(0);
+  await Bun.write('/tmp/qml-flea-media-poster.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+  await run(`players[0].source=${JSON.stringify(audio)}`);
+  await until('players[0]?.hasAudio&&!players[0].hasVideo&&players[0].duration>500');
+  expect(await run('players[0].error')).toBe(0);
+ }finally{browser?.close();sandbox.close();}
+},30000);

package/test/qml-flea-navigation-backend.test.js

@@ -0,0 +1,35 @@
+import {test,expect} from 'bun:test';
+import {mkdirSync} from 'node:fs';
+import {join} from 'node:path';
+import {createBrowser} from '../lib/headless-shell.js';
+import {fleaSandbox} from './helpers/flea-sandbox.js';
+const flea=process.env.BUNINU_FLEA_ROOT,omarchy=process.env.BUNINU_OMARCHY_ROOT;
+test.skipIf(!flea||!omarchy||!process.env.FLEA_BIN)('Flea expands tilde and preserves language icons after repeated returns from an empty home directory',async()=>{
+ const sandbox=fleaSandbox(flea,omarchy),oldPath=process.env.FLEA_PATH;
+ let browser;
+ try{
+  const listing=join(sandbox.dir,'listing');mkdirSync(listing);
+  for(const name of ['alpha','beta','gamma'])mkdirSync(join(listing,name));
+  for(const name of ['a.md','b.js','c.json','d.qml','e.css','f.md'])await Bun.write(join(listing,name),'test');
+  process.env.FLEA_PATH=listing;
+  browser=await createBrowser({spareRenderer:false,rendererTimeout:30000});await browser.context.resize(800,600);
+  await browser.context.addInitScript(`globalThis.qmlNodes=[];let runtime;Object.defineProperty(globalThis,'__qmlRuntime',{get:()=>runtime,set:r=>{runtime=r;const describe=r.describe;r.describe=(v,t,...a)=>{qmlNodes.push({v,t});return describe(v,t,...a)}}});`);
+  await browser.context.navigate(Bun.pathToFileURL(join(sandbox.flea,'ui/boot/shell.qml')).href);
+  const run=s=>browser.context.evaluate(s),pane=`qmlNodes.find(n=>n.t.includes('Pane')).v`;
+  const state=()=>run(`(()=>{const p=${pane};return {path:p.path,state:p.listingState,busy:p.listInFlight}})()`);
+  async function until(fn){for(let i=0;i<150;i++){if(await fn())return;await Bun.sleep(30);}throw Error(JSON.stringify(await state()));}
+  const icons=()=>run(`qmlNodes.filter(n=>n.t.includes('Row')).map(({v})=>({name:v.row?.n,slug:v.langSlug,live:v.live,item:!!v.langLoader?.item})).filter(v=>v.live&&v.slug)`);
+  await until(async()=>(await state()).state==='ready');
+  for(let attempt=0;attempt<3;attempt++){
+   await browser.context.press('l',{code:'KeyL',modifiers:2});
+   await browser.context.press('~',{code:'Backquote',modifiers:8});
+   await browser.context.press('Enter',{code:'Enter'});
+   await until(async()=>{const s=await state();return s.path===sandbox.values.HOME&&!s.busy&&s.state==='empty'});
+   expect((await state()).state).toBe('empty');
+   await run(`${pane}.goBack()`);
+   await until(async()=>{const s=await state();return s.path===listing&&s.state==='ready'&&!s.busy});
+   await until(async()=>{const rows=await icons();return rows.length===6&&rows.every(v=>v.item)});
+   expect((await icons()).map(v=>v.name).sort()).toEqual(['a.md','b.js','c.json','d.qml','e.css','f.md']);
+  }
+ }finally{browser?.close();if(oldPath===undefined)delete process.env.FLEA_PATH;else process.env.FLEA_PATH=oldPath;sandbox.close();}
+},60000);

package/test/qml-flea-navigation-timing.test.js

@@ -0,0 +1,147 @@
+// Opt-in integration: unmodified packaged QML and the real installed Flea binary.
+import { test, expect } from 'bun:test';
+import { join } from 'node:path';
+import {
+  mkdirSync,
+  writeFileSync,
+  readdirSync,
+  statSync,
+  unlinkSync,
+} from 'node:fs';
+import { createBrowser } from '../lib/headless-shell.js';
+import { fleaSandbox } from './helpers/flea-sandbox.js';
+const root = process.env.BUNINU_FLEA_ROOT,
+  omarchy = process.env.BUNINU_OMARCHY_ROOT,
+  binary = process.env.FLEA_BIN;
+test.skipIf(!root || !omarchy || !binary)(
+  'measure real Flea directory navigation and raw capture',
+  async () => {
+    const sandbox = fleaSandbox(root, omarchy),
+      oldPath = process.env.FLEA_PATH;
+    const home = sandbox.values.HOME,
+      folder = join(home, 'Documents');
+    mkdirSync(folder);
+    writeFileSync(join(home, 'hello.txt'), 'hello');
+    writeFileSync(join(folder, 'inside.txt'), 'inside');
+    process.env.FLEA_PATH = home;
+    let browser;
+    try {
+      browser = await createBrowser({
+        spareRenderer: false,
+        rendererTimeout: 30000,
+      });
+      await browser.context.addInitScript(
+        `globalThis.qmlErrors=[];addEventListener('error',e=>qmlErrors.push(String(e.error?.stack||e.message)));const original=console.error;console.error=(...args)=>{qmlErrors.push(args.map(String).join(' '));original(...args);};`,
+      );
+      if (process.env.BUNINU_QML_TIMING_TRACE)
+        await browser.context.addInitScript(`
+        globalThis.qmlTiming=[];
+        const stamp=(kind,detail)=>qmlTiming.push({at:Date.now(),kind,detail});
+        stamp('init',!!globalThis.__qmlHost);
+        const microtask=globalThis.queueMicrotask;
+        globalThis.queueMicrotask=fn=>microtask(()=>{const start=Date.now();try{return fn();}finally{const ms=Date.now()-start;if(ms>10)stamp('microtask',{ms,fn:String(fn).slice(0,180)});}});
+        const timeout=globalThis.setTimeout;
+        globalThis.setTimeout=(fn,delay,...args)=>timeout(()=>{const start=Date.now();try{return fn(...args);}finally{const ms=Date.now()-start;if(ms>10)stamp('timer',{ms,delay,fn:String(fn).slice(0,180)});}},delay);
+
+        if(globalThis.__qmlHost){
+          const host=globalThis.__qmlHost,run=host.run;
+          for(const name of ['compile','read','write']){
+            const original=host[name];if(!original)continue;
+            host[name]=(...args)=>{const start=Date.now();try{return original(...args);}finally{const ms=Date.now()-start;if(ms>10)stamp('host-'+name,{ms,path:args[0]});}};
+          }
+
+          host.run=(command,callback,options={})=>{
+            const traced={...options};
+            for(const channel of ['stdout','stderr']) if(options[channel]) traced[channel]=chunk=>{
+              stamp(channel,String(chunk).slice(0,500));
+              const start=Date.now();try{return options[channel](chunk);}finally{stamp(channel+'-handled',Date.now()-start);}
+            };
+            const child=run.call(host,command,callback,traced),write=child.write;
+            if(write)child.write=text=>{stamp('stdin',String(text).slice(0,500));return write(text);};
+            return child;
+          };
+        }
+        addEventListener('keydown',e=>stamp('keydown',e.key),true);
+      `);
+      await browser.context.navigate(
+        Bun.pathToFileURL(join(sandbox.flea, 'ui/boot/shell.qml')).href,
+      );
+      const text = () => browser.context.evaluate('document.body.innerText');
+      const until = async (predicate) => {
+        for (let n = 0; n < 150; n++) {
+          if (await predicate()) return;
+          await Bun.sleep(40);
+        }
+        throw Error('Flea did not settle: ' + (await text()));
+      };
+      await until(async () => (await text()).includes('hello.txt'));
+      const results = [];
+      for (let i = 0; i < 6; i++) {
+        const entering = i % 2 === 0,
+          key = entering ? 'ArrowRight' : 'ArrowLeft';
+        const start = performance.now();
+        await browser.context.press(key, { code: key });
+        const dispatch = performance.now();
+        for (let n = 0; n < 300; n++) {
+          const content = await text();
+          if (
+            entering
+              ? content.includes('inside.txt') && !content.includes('hello.txt')
+              : content.includes('hello.txt') && !content.includes('inside.txt')
+          )
+            break;
+          if (n === 299) throw Error('Navigation timed out: ' + key);
+          await Bun.sleep(10);
+        }
+        const ready = performance.now();
+        const frame = JSON.parse(
+          await browser.context.screenshot({ format: 'bgra' }),
+        );
+        if (frame.path) unlinkSync(frame.path);
+        const painted = performance.now();
+        results.push({
+          key,
+          dispatchMs: dispatch - start,
+          contentMs: ready - start,
+          captureMs: painted - ready,
+          totalMs: painted - start,
+        });
+        await Bun.sleep(250);
+      }
+      const fsTimes = [];
+      for (let i = 0; i < 20; i++) {
+        const start = performance.now();
+        for (const dir of [home, folder])
+          for (const name of readdirSync(dir)) statSync(join(dir, name));
+        fsTimes.push(performance.now() - start);
+      }
+      const trace = process.env.BUNINU_QML_TIMING_TRACE
+        ? JSON.parse(
+            await browser.context.evaluate('JSON.stringify(qmlTiming)'),
+          )
+        : [];
+      const report = {
+        viewport: '800x600',
+        results,
+        fsReadBothDirsMs: fsTimes,
+        trace,
+      };
+      await Bun.write(
+        '/tmp/flea-navigation-timing.json',
+        JSON.stringify(report, null, 2),
+      );
+      console.log(JSON.stringify(report));
+      // Wait through the upstream prebuild driver's first idle tick too.
+      await Bun.sleep(1500);
+      expect(await browser.context.evaluate('JSON.stringify(qmlErrors)')).toBe(
+        '[]',
+      );
+    } finally {
+      browser?.close();
+      if (oldPath === undefined) delete process.env.FLEA_PATH;
+      else process.env.FLEA_PATH = oldPath;
+      sandbox.close();
+    }
+  },
+  60000,
+);

package/test/qml-flea-preview-backend.test.js

@@ -0,0 +1,53 @@
+import { test, expect } from 'bun:test';
+import { join } from 'node:path';
+import { createBrowser } from '../lib/headless-shell.js';
+import { encodeImage } from '../lib/paint/frame.js';
+import { fleaSandbox } from './helpers/flea-sandbox.js';
+const root=process.env.BUNINU_FLEA_ROOT,omarchy=process.env.BUNINU_OMARCHY_ROOT,binary=process.env.FLEA_BIN;
+test.skipIf(!root||!omarchy||!binary)('official Flea backend opens and switches real text and image previews',async()=>{
+ const sandbox=fleaSandbox(root,omarchy),oldPath=process.env.FLEA_PATH;
+ let browser;
+ try {
+  process.env.FLEA_PATH=sandbox.values.HOME;
+  await Bun.write(join(sandbox.values.HOME,'first.txt'),'First real Flea preview\nDOM textures preserve the previous frame.\n'+'A long preview line.\n'.repeat(150));
+  await Bun.write(join(sandbox.values.HOME,'second.txt'),'Second real Flea preview\nThe official backend loaded this file.\n'+'Another long preview.\n'.repeat(170));
+  const rgba=new Uint8Array(320*160*4);
+  for(let y=0;y<160;y++)for(let x=0;x<320;x++)rgba.set(x<80?[0,100,255,255]:[255,0,0,255],(y*320+x)*4);
+  await Bun.write(join(sandbox.values.HOME,'third.png'),await encodeImage(rgba,320,160));
+  browser=await createBrowser({spareRenderer:false,rendererTimeout:20000});
+  await browser.context.resize(900,600);
+  await browser.context.addInitScript(`globalThis.qmlReaders=[];globalThis.qmlRows=[];let runtime;Object.defineProperty(globalThis,'__qmlRuntime',{get:()=>runtime,set:r=>{runtime=r;const describe=r.describe;r.describe=(v,t,...a)=>{if(t.includes('PreviewText'))qmlReaders.push(v);if(t.includes('Row'))qmlRows.push(v);return describe(v,t,...a)}}});globalThis.errors=[];addEventListener('error',e=>errors.push(String(e.error?.stack||e.message)));const old=console.error;console.error=(...a)=>{errors.push(a.map(String).join(' '));old(...a)};`);
+  await browser.context.navigate(Bun.pathToFileURL(join(sandbox.flea,'ui/boot/shell.qml')).href);
+  const run=code=>browser.context.evaluate(code);
+  async function until(fn){for(let i=0;i<120;i++){if(await fn())return;await Bun.sleep(30);}throw Error(await run('document.body.innerText+JSON.stringify(errors)'));}
+  await until(async()=>(await run('document.body.innerText')).includes('first.txt'));
+  const second=await run(`(()=>{const e=[...document.querySelectorAll('[data-qml-type=Text]')].find(e=>e.textContent==='second.txt'&&e.getBoundingClientRect().width>0);const r=e.getBoundingClientRect();return[r.x+r.width/2,r.y+r.height/2]})()`);
+  await browser.context.click(...second);await run('0');
+  expect(await run(`qmlRows.some(v=>v.row?.n==='second.txt'&&v.selected)`)).toBe(true);
+  const pt=await run(`(()=>{const e=[...document.querySelectorAll('[data-qml-type=Text]')].find(e=>e.textContent==='first.txt'&&e.getBoundingClientRect().width>0);if(!e)throw Error('row missing');const r=e.getBoundingClientRect();return [r.x+r.width/2,r.y+r.height/2]})()`);
+  await browser.context.click(...pt);
+  await browser.context.press(' ',{code:'Space'});
+  await until(async()=>(await run('document.body.innerText')).includes('First real Flea preview'));
+  await until(async()=>!(await run('document.body.innerText')).includes('reading'));
+  await Bun.write('/tmp/flea-real-preview-first.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+  await run(`qmlReaders.find(r=>r.active&&r.list).list.contentY=400`);await run('0');
+  expect(await run(`qmlReaders.find(r=>r.active&&r.list).list.contentY`)).toBeGreaterThan(0);
+  await browser.context.press('ArrowDown',{code:'ArrowDown'});
+  await until(async()=>(await run('document.body.innerText')).includes('Second real Flea preview'));
+  await until(async()=>await run(`qmlReaders.some(r=>r.active&&r.path.endsWith('/second.txt')&&r.list&&r.list.contentY===0)`));
+  expect(await run(`qmlReaders.find(r=>r.active&&r.path.endsWith('/second.txt')).list.contentY`)).toBe(0);
+  await Bun.sleep(100);
+  await Bun.write('/tmp/flea-real-preview-second.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+  await browser.context.press('ArrowDown',{code:'ArrowDown'});
+  await until(async()=>await run(`[...document.querySelectorAll('img')].some(e=>e.src.endsWith('/third.png')&&e.complete&&e.naturalWidth===320)`));
+  await until(async()=>!(await run('document.body.innerText')).includes('reading'));
+  const png=Buffer.from(await browser.context.screenshot({format:'png'}),'base64');
+  await Bun.write('/tmp/flea-real-preview-image.png',png);
+  const {CanvasKit:kit}=await import('../lib/renderer/page-renderer.js').then(m=>m.loadGraphics());
+  const image=kit.MakeImageFromEncoded(png);
+  try { expect([...image.readPixels(450,300,{width:1,height:1,colorType:kit.ColorType.RGBA_8888,alphaType:kit.AlphaType.Unpremul,colorSpace:kit.ColorSpace.SRGB})]).toEqual([255,0,0,255]); }
+  finally { image.delete(); }
+  expect(await run('errors')).toEqual([]);
+  await browser.context.press('Escape',{code:'Escape'});
+ }finally{browser?.close();if(oldPath===undefined)delete process.env.FLEA_PATH;else process.env.FLEA_PATH=oldPath;sandbox.close();}
+},45000);