buninu-browser 0.3.0 → 0.5.0

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

@@ -0,0 +1,146 @@
+// Opt-in integration against an unchanged Flea/Omarchy checkout. This never
+// substitutes backend replies. Without FLEA_BIN the real unavailable state is expected.
+import { test, expect } from 'bun:test';
+import { mkdtempSync, mkdirSync, symlinkSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createBrowser } from '../lib/headless-shell.js';
+const flea = process.env.BUNINU_FLEA_ROOT,
+  omarchy = process.env.BUNINU_OMARCHY_ROOT;
+test.skipIf(!flea || !omarchy)(
+  'unchanged Flea boots and opens, switches and closes its real settings panel',
+  async () => {
+    const dir = mkdtempSync('/tmp/qml-flea-app-'),
+      saved = {};
+    const variables = {
+      HOME: join(dir, 'home'),
+      XDG_CONFIG_HOME: join(dir, 'config'),
+      XDG_STATE_HOME: join(dir, 'state'),
+      XDG_DATA_HOME: join(dir, 'data'),
+      XDG_CACHE_HOME: join(dir, 'cache'),
+      QML_IMPORT_PATH: join(dir, 'imports'),
+      HYPRLAND_INSTANCE_SIGNATURE: '',
+      FLEA_BIN: process.env.FLEA_BIN || join(dir, 'no-flea-backend'),
+    };
+    for (const [key, value] of Object.entries(variables)) {
+      saved[key] = process.env[key];
+      process.env[key] = value;
+    }
+    for (const key of [
+      'HOME',
+      'XDG_CONFIG_HOME',
+      'XDG_STATE_HOME',
+      'XDG_DATA_HOME',
+      'XDG_CACHE_HOME',
+    ])
+      mkdirSync(variables[key], { recursive: true });
+    mkdirSync(join(dir, 'imports/qs'), { recursive: true });
+    for (const name of ['Commons', 'Ui'])
+      symlinkSync(
+        resolve(omarchy, 'shell', name),
+        join(dir, 'imports/qs', name),
+        'dir',
+      );
+    let browser;
+    try {
+      browser = await createBrowser({
+        spareRenderer: false,
+        rendererTimeout: 60000,
+      });
+      await browser.context.addInitScript(
+        `globalThis.qmlErrors=[];addEventListener('error',e=>qmlErrors.push(String(e.error?.stack||e.message)));const originalError=console.error;console.error=(...args)=>{qmlErrors.push(args.map(String).join(' '));originalError(...args);};`,
+      );
+      await browser.context.navigate(
+        Bun.pathToFileURL(resolve(flea, 'ui/boot/shell.qml')).href,
+      );
+      const text = () => browser.context.evaluate('document.body.innerText');
+      const until = async (fn) => {
+        for (let i = 0; i < 150; i++) {
+          if (await fn()) return;
+          await Bun.sleep(40);
+        }
+        throw Error('Flea did not settle: ' + (await text()));
+      };
+      await until(async () => (await text()).includes('PLACES'));
+      const clickExpression = async (expression) => {
+        const point = JSON.parse(
+          await browser.context.evaluate(
+            `(()=>{const e=${expression};if(!e)throw Error('Missing Flea control');const r=e.getBoundingClientRect();return JSON.stringify([r.x+r.width/2,r.y+r.height/2]);})()`,
+          ),
+        );
+        await browser.context.click(...point);
+      };
+      await clickExpression(`document.querySelector('[aria-label="sliders"]')`);
+      await until(async () => (await text()).includes('Settings'));
+      const visibleLabel = (label) =>
+        `[...document.querySelectorAll('[data-qml-type=Text]')].find(e=>e.textContent===${JSON.stringify(label)}&&e.getBoundingClientRect().width>0&&e.getBoundingClientRect().height>0)`;
+      await clickExpression(visibleLabel('Display'));
+      await until(async () => (await text()).includes('Text size'));
+      await Bun.write(
+        '/tmp/buninu-flea-settings-display.png',
+        Buffer.from(
+          await browser.context.screenshot({ format: 'png' }),
+          'base64',
+        ),
+      );
+      await clickExpression(visibleLabel('Keys'));
+      await until(async () => (await text()).includes('Keybinding preset'));
+      await browser.context.press('Escape', { code: 'Escape' });
+      await until(async () => !(await text()).includes('Settings'));
+      await browser.context.press('l', { modifiers: 2 });
+      await until(
+        async () =>
+          await browser.context.evaluate(
+            'document.activeElement?.tagName==="INPUT"',
+          ),
+      );
+      await browser.context.type('/tmp/example');
+      expect(
+        await browser.context.evaluate('document.activeElement.value'),
+      ).toBe('/tmp/example');
+      await browser.context.press('Escape');
+      await until(
+        async () =>
+          await browser.context.evaluate(
+            'document.activeElement?.tagName!=="INPUT"',
+          ),
+      );
+      await browser.context.press('?', { code: 'Slash', modifiers: 8 });
+      await until(async () => (await text()).includes('esc closes'));
+      await browser.context.press('Escape');
+      await browser.context.press('a');
+      await until(async () => (await text()).includes('Connect and save'));
+      await browser.context.type('example.invalid');
+      await until(async () => (await text()).includes('smb://example.invalid'));
+      await clickExpression(visibleLabel('SFTP'));
+      await until(async () =>
+        (await text()).includes('sftp://example.invalid'),
+      );
+      await Bun.write(
+        '/tmp/buninu-flea-network.png',
+        Buffer.from(
+          await browser.context.screenshot({ format: 'png' }),
+          'base64',
+        ),
+      );
+      await browser.context.press('Escape');
+      expect(await browser.context.evaluate('JSON.stringify(qmlErrors)')).toBe(
+        '[]',
+      );
+      await Bun.write(
+        '/tmp/buninu-flea-app.png',
+        Buffer.from(
+          await browser.context.screenshot({ format: 'png' }),
+          'base64',
+        ),
+      );
+    } finally {
+      browser?.close();
+      for (const [key, value] of Object.entries(saved)) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+      rmSync(dir, { recursive: true, force: true });
+    }
+  },
+  120000,
+);

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);