flea-qml 0.0.0-stage → 0.2.0

package/test/highlight-launcher.test.js

@@ -0,0 +1,35 @@
+import {test,expect,afterAll} from 'bun:test';
+import {mkdtempSync,mkdirSync,copyFileSync,writeFileSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+const root=mkdtempSync(join(tmpdir(),'flea-highlight-'));
+afterAll(()=>rmSync(root,{recursive:true,force:true}));
+let serial=0;
+async function run(name,{failure=false,sibling=false,filetype=null}={}) {
+ const dir=join(root,String(++serial)),src=join(dir,'flea','src'),bin=join(dir,'commands');
+ mkdirSync(src,{recursive:true});mkdirSync(bin);
+ // Isolate discovery from the real sibling checkout without changing it or using links.
+ copyFileSync(new URL('../src/highlight.js',import.meta.url),join(src,'highlight.js'));
+ const path=join(dir,'sample with spaces.js');writeFileSync(path,'const n = 1;');
+ const args=['--cat','--edit',...(filetype?['-filetype',filetype]:[]),path];
+ const body=`if (JSON.stringify(process.argv.slice(2)) !== JSON.stringify(${JSON.stringify(args)})) process.exit(9);\nprocess.stdout.write('\\x1b[31mconst\\x1b[0m n = 1;\\n');\n`;
+ writeFileSync(join(bin,name),`#!${process.execPath}\n${failure?'process.exit(7);':body}`,{mode:0o755});
+ if(sibling){const target=join(dir,'jsmdcui','src');mkdirSync(target,{recursive:true});writeFileSync(join(target,'index.js'),body);}
+ const script=join(src,'probe.js');
+ writeFileSync(script,`import {highlightFile,jsmdcui} from './highlight.js'; console.log(JSON.stringify({command:jsmdcui(),lines:await highlightFile(${JSON.stringify(path)},undefined,${JSON.stringify(filetype)})}));`);
+ const proc=Bun.spawn([process.execPath,script],{env:{...process.env,PATH:bin},stdout:'pipe',stderr:'pipe'});
+ const [text,err,code]=await Promise.all([new Response(proc.stdout).text(),new Response(proc.stderr).text(),proc.exited]);
+ expect({code,err}).toEqual({code:0,err:''});
+ return {result:JSON.parse(text),bin};
+}
+for(const name of ['jmi','jsmdcui'])test(`executes PATH ${name} launcher without guessing its install layout`,async()=>{
+ const {result,bin}=await run(name);expect(result.command).toEqual([join(bin,name)]);expect(result.lines[0]).toEqual([1,'const',0,' n = 1;']);
+});
+test('failed launcher preserves plain-text fallback',async()=>{expect((await run('jmi',{failure:true})).result.lines).toBeNull();});
+test('sibling checkout still runs through Bun before PATH launchers',async()=>{
+ const {result}=await run('jmi',{failure:true,sibling:true});expect(result.command.length).toBe(2);expect(result.command[1]).toEndWith('/jsmdcui/src/index.js');expect(result.lines[0][0]).toBe(1);
+});
+
+test('passes a language override as the single-dash jsmdcui setting',async()=>{
+ expect((await run('jmi',{filetype:'v'})).result.lines[0][0]).toBe(1);
+});

package/test/html-preview.test.js

@@ -0,0 +1,22 @@
+import {test,expect} from 'bun:test';
+import {previewHtml,html,HTML_LIMIT} from '../src/html.js';
+import {mkdtemp,writeFile,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+test('HTML is rebuilt with fixed tags, no source attributes, nested divs and literal entities',()=>{
+ expect(previewHtml('<div id=x><div onclick="evil()">A &amp; B</div></div>')).toBe('<div><div>A &amp; B</div></div>');
+ expect(previewHtml('<textarea><img src=x onerror="evil()"></textarea>')).toBe('&lt;img src=x onerror="evil()"&gt;');
+ expect(previewHtml('<script>globalThis.__htmlProbe++</script><style>bad</style><p>OK</p>')).toBe('<p>OK</p>');
+ expect(previewHtml('<svg><foreignObject><b>hidden</b></foreignObject></svg><p>OK</p>')).toBe('<p>OK</p>');
+ expect(()=>previewHtml('x'.repeat(HTML_LIMIT+1))).toThrow();
+});
+test('HTML file replies are bounded and cancellation produces no result',async()=>{
+ const dir=await mkdtemp(join(tmpdir(),'flea-html-'));
+ try{
+  const path=join(dir,'test.html');await writeFile(path,'<h1 onmouseover="evil()">Hello</h1>');
+  expect(await html({path,token:4,slot:'look'})).toMatchObject({state:'ready',html:'<h1>Hello</h1>',token:4,slot:'look'});
+  expect(await html({path,cancel:true})).toBe(null);
+  expect((await html({path:dir})).state).toBe('failed');
+  await writeFile(path,'x'.repeat(HTML_LIMIT+1));expect((await html({path})).state).toBe('failed');
+ }finally{await rm(dir,{recursive:true,force:true})}
+});

package/test/input.test.js

@@ -0,0 +1,15 @@
+import { test, expect } from 'bun:test';
+const source=(await Bun.file(new URL('../ui/js/Input.js',import.meta.url)).text()).replace(/^\.pragma library\s*/,'');
+const warnings=[];
+const {pasteInto}=new Function('console',source+'; return {pasteInto};')({warn: e=>warnings.push(e)});
+test('paste synchronous and asynchronous clipboard text',async()=>{
+ const values=[];pasteInto({clipboardText:()=> 'hello\nother'},v=>values.push(v));
+ pasteInto({clipboardText:()=>Promise.resolve('中文😀')},v=>values.push(v));
+ await Bun.sleep(0);expect(values).toEqual(['hello','中文😀']);
+});
+test('clipboard exceptions and rejections are caught',async()=>{
+ warnings.length=0;
+ pasteInto({clipboardText:()=>{throw Error('sync')}},()=>{});
+ pasteInto({clipboardText:()=>Promise.reject(Error('async'))},()=>{});
+ await Bun.sleep(0);expect(warnings.length).toBe(2);
+});

package/test/keymap.test.js

@@ -0,0 +1,26 @@
+import { test, expect } from "bun:test";
+
+// flea-qml's own changes to the generated key table (ui/js/Keymap.js), checked in every preset.
+const source = (await Bun.file(new URL("../ui/js/Keymap.js", import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm, "");
+let next = 1000;
+const named = { ControlModifier: 0x04000000, AltModifier: 0x08000000, ShiftModifier: 0x02000000, MetaModifier: 0x10000000,
+  Key_Return: 16777220, Key_Enter: 16777221, Key_D: 68, Key_I: 73, Key_Equal: 0x3d };
+const Qt = new Proxy(named, { get: (t, k) => (k in t ? t[k] : (t[k] = next++)) });
+const { lookupFor } = new Function("Qt", source + ";return {lookupFor};")(Qt);
+const PRESETS = ["default", "vim", "mac", "windows"];
+
+test("Alt+Enter opens Properties in every preset, as Windows, KDE and GNOME do", () => {
+  for (const preset of PRESETS) {
+    expect(lookupFor(preset, named.Key_Return, "", named.AltModifier)).toBe("properties");
+    expect(lookupFor(preset, named.Key_Enter, "", named.AltModifier)).toBe("properties");
+  }
+  expect(lookupFor("mac", named.Key_I, "", named.MetaModifier)).toBe("properties");
+});
+
+test("= and Alt+= measure folders in every preset; Ctrl+= stays the text size", () => {
+  for (const preset of PRESETS) {
+    expect(lookupFor(preset, named.Key_Equal, "=", 0)).toBe("measureDirs");
+    expect(lookupFor(preset, named.Key_Equal, "", named.AltModifier)).toBe("measureAllDirs");
+    expect(lookupFor(preset, named.Key_Equal, "", named.ControlModifier)).toBe("textSizeUp");
+  }
+});

package/test/language-icons.test.js

@@ -0,0 +1,36 @@
+import {test,expect} from 'bun:test';
+async function load(name,exports,deps={}) {
+ const source=(await Bun.file(new URL('../ui/js/'+name+'.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ return new Function(...Object.keys(deps),source+';return {'+exports+'};')(...Object.values(deps));
+}
+const Icons=await load('Icons','isEmoji');
+const Format=await load('Format','isSymlink');
+
+test('emoji and directory rows never load language components, even during Find',async()=>{
+ const Lang=await load('LangMarks','slugForRow,syncMark',{Icons,Format,Qt:{createComponent(){throw Error('unnecessary component load')}}});
+ for(const row of [{n:'main.js',i:'📄',p:33188},{n:'code.py',i:'🐍',p:33188},{n:'folder.rs',d:true}]) {
+  const owner={langSlug:Lang.slugForRow(row),thumbDrawn:false,langLoader:null};
+  expect(owner.langSlug).toBe('');
+  Lang.syncMark(owner,{parent:{}},'LangMarkLoader.qml',1);
+  expect(owner.langLoader).toBeNull();
+ }
+});
+
+test('visible language logos load once and release when replaced by emoji or thumbnails',async()=>{
+ let loads=0,released=0,componentReleased=0;
+ const Lang=await load('LangMarks','slugForRow,syncMark',{Icons,Format,Qt:{createComponent(){loads++;return {
+  status:1,createObject(){return {active:true,destroy(){released++;}}},destroy(){componentReleased++;}
+ };}}});
+ const owner={langSlug:Lang.slugForRow({n:'main.js',i:'file',p:33188}),thumbDrawn:false,langLoader:null};
+ const glyph={parent:{}};
+ expect(owner.langSlug).toBe('javascript');
+ Lang.syncMark(owner,glyph,'LangMarkLoader.qml',1);
+ Lang.syncMark(owner,glyph,'LangMarkLoader.qml',1);
+ expect(loads).toBe(1);expect(componentReleased).toBe(1);
+ owner.langSlug=Lang.slugForRow({n:'main.js',i:'📄',p:33188});
+ Lang.syncMark(owner,glyph,'LangMarkLoader.qml',1);
+ expect(released).toBe(1);expect(owner.langLoader).toBeNull();
+ owner.langSlug='javascript';owner.thumbDrawn=true;
+ Lang.syncMark(owner,glyph,'LangMarkLoader.qml',1);
+ expect(loads).toBe(1);
+});

package/test/launcher.test.js

@@ -0,0 +1,51 @@
+import {test,expect} from 'bun:test';
+import {EventEmitter} from 'node:events';
+import {browserPackage,browserCommand,selectFrontend,detectKitty,entryURL} from '../index.js';
+import {fileURLToPath} from 'node:url';
+import info from '../package.json';
+import {isAbsolute} from 'node:path';
+
+test('launcher follows browser package manager order',()=>{
+ const which = names => name => names.includes(name) ? '/bin/'+name : null;
+ expect(browserCommand(['file:///a%20b.qml'],which(['npx','bun','bunx']))).toEqual(['/bin/npx','--loglevel=error','-p',browserPackage(),'--','buninu-browser','file:///a%20b.qml']);
+ expect(browserCommand([],which(['npx','bunx']))).toEqual(['/bin/bunx',browserPackage()]);
+ expect(browserCommand([],which(['bun']))).toEqual(['/bin/bun','x',browserPackage()]);
+ expect(browserCommand([],which([]),'/running/bun')).toEqual(['/running/bun','x',browserPackage()]);
+ expect(isAbsolute(fileURLToPath(entryURL))).toBe(true);
+});
+test('explicit frontends override detection on Windows and Linux',()=>{
+ expect(selectFrontend([],true,'win32').frontend).toBe('--casty');
+ expect(selectFrontend([],false,'win32').frontend).toBe('--win32');
+ for(const platform of ['linux','android']) expect(selectFrontend([],false,platform).frontend).toBe('--wayland');
+ for(const flag of ['--casty','--wayland','--win32','--headless']) expect(selectFrontend([flag,'--help'],true,'win32')).toEqual({frontend:flag,args:['--help']});
+ expect(selectFrontend(['--future-frontend','arg'],false)).toEqual({frontend:'--future-frontend',args:['arg']});
+});
+function terminal(reply) {
+ const input=new EventEmitter(),output=new EventEmitter();
+ input.isTTY=output.isTTY=true;input.isRaw=false;input.paused=true;
+ input.isPaused=()=>input.paused;input.pause=()=>{input.paused=true;};input.resume=()=>{input.paused=false;};input.setRawMode=v=>{input.isRaw=v;};input.unshift=()=>{};
+ output.write=query=>{const id=/i=(\d+)/.exec(query)[1];if(reply!==null)queueMicrotask(()=>{input.emit('data',Buffer.from(`\x1b_Gi=${id};${reply}\x1b`));input.emit('data',Buffer.from('\\'));});};
+ return {input,output};
+}
+test('graphics query handles fragmented replies and restores terminal on timeout',async()=>{
+ for(const [reply,expected] of [['OK',true],['OK Buninu1 bgra',true],['EINVAL',false],[null,false]]) {
+  const {input,output}=terminal(reply);
+  expect(await detectKitty(input,output,5)).toBe(expected);
+  expect(input.isRaw).toBe(false);expect(input.paused).toBe(true);expect(input.listenerCount('data')).toBe(0);
+ }
+ expect(await detectKitty({isTTY:false},{isTTY:true})).toBe(false);
+});
+
+test('browser package comes from the script without shell execution',()=>{
+ expect(browserPackage()).toBe(info.scripts.browser.split(/\s+/)[1]);
+ expect(browserPackage('bunx buninu-browser@9.8.7')).toBe('buninu-browser@9.8.7');
+ expect(()=>browserPackage('bunx buninu-browser@1; echo bad')).toThrow();
+});
+
+test('version flags report the package and pinned browser versions', async()=>{
+ for (const flag of ['--version','-V']) {
+  const child = Bun.spawn([process.execPath, fileURLToPath(new URL('../index.js', import.meta.url)), flag], {stdout:'pipe',stderr:'pipe'});
+  expect(await new Response(child.stdout).text()).toBe(`flea-qml ${info.version}\n${browserPackage()} (pinned)\n`);
+  expect(await child.exited).toBe(0);
+ }
+});

package/test/manual-archive-here-ui.mjs

@@ -0,0 +1,47 @@
+// bun test/manual-archive-here-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync,existsSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+await Bun.write(join(dir,'notes.txt'),'line of preview text\n'.repeat(200));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nimport "../js/Tabs.js" as Tabs\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testTabs=Tabs;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ const {archive}=await import('../src/archiveops.js');
+ const source=join(dir,'source');mkdirSync(source);
+ for(let i=0;i<8;i++)await Bun.write(join(source,`file${i}.txt`),'test');
+ await new Promise((resolve,reject)=>archive({op:'compress',paths:[source],dest:join(dir,'sample.zip'),format:'zip'},m=>{if(m.t==='archivedone')m.ok?resolve():reject(Error(m.err))}));
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+ await run('for(let i=0;i<testBody.currentPane.total;i++)if(testBody.currentPane.rowFor(i)?.n==="sample.zip")testBody.currentPane.selectOnly(i,0)');
+ await until('testBody.currentPane.previewColumnItem?.meta?.topEntries===1');
+ assert.equal(await run('testBody.currentPane.previewColumnItem.meta.entries'),9);
+ console.log('PASS right preview carries 9 members / 1 top-level item');
+ await run('testBody.currentPane.act("preview")');
+ await until('testBody.currentPane.quickLook().archiveMeta?.topEntries===1');
+ assert.equal(await run('testBody.currentPane.quickLook().archiveMeta.entries'),9);
+ console.log('PASS Quick Look carries 9 members / 1 top-level item');
+ const button=await run('(()=>{const e=[...document.querySelectorAll("[data-qml-type=Text]")].filter(e=>e.textContent==="Extract here"&&e.getBoundingClientRect().width>0).at(-1);const r=e.getBoundingClientRect();return {x:r.x+r.width/2,y:r.y+r.height/2}})()');
+ await browser.context.click(button.x,button.y);
+ for(let i=0;i<100&&!existsSync(join(dir,'source copy'));i++)await Bun.sleep(100);
+ assert(existsSync(join(dir,'source copy')),'Extract here should run without confirmation');
+ console.log('PASS clicking Quick Look Extract here extracts without a confirmation dialog');
+ await run('testBody.currentPane.quickLook().close()');
+ await until('!testBody.currentPane.listInFlight');
+ await run('for(let i=0;i<testBody.currentPane.total;i++)if(testBody.currentPane.rowFor(i)?.n==="sample.zip")testBody.currentPane.selectOnly(i,0)');
+ await until('testBody.currentPane.previewColumnItem?.meta?.topEntries===1');
+ const right=await run('(()=>{const e=[...document.querySelectorAll("[data-qml-type=Text]")].find(e=>e.textContent==="Extract here"&&e.getBoundingClientRect().width>0);const r=e.getBoundingClientRect();return {x:r.x+r.width/2,y:r.y+r.height/2}})()');
+ await browser.context.click(right.x,right.y);
+ for(let i=0;i<100&&!existsSync(join(dir,'source copy 2'));i++)await Bun.sleep(100);
+ assert(existsSync(join(dir,'source copy 2')),'right preview Extract here should run without confirmation');
+ console.log('PASS clicking right preview Extract here extracts without confirmation');
+
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}

package/test/manual-code-scroll.mjs

@@ -0,0 +1,28 @@
+// bun test/manual-code-scroll.mjs (requires sibling buninu-browser).
+import {rm} from 'node:fs/promises';
+import {createBrowser} from '../../buninu-browser/lib/headless-shell.js';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const qml=repo+'ui/boot/.scroll-check-'+process.pid+'.qml';
+const text='x'.repeat(512)+'/system/bin/linker64\n'+Array.from({length:150},(_,i)=>'line '+i).join('\n');
+await Bun.write(qml,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow {width:500;height:300;color:"#171b22";Flea.CodeLines {id:code;anchors.fill:parent;fromText:true;text:${JSON.stringify(text)};active:true;scrolls:true;Component.onCompleted:globalThis.code=code;Flea.FastScrollHandler {flickable:code.viewport}}}`);
+const browser=await createBrowser({spareRenderer:false});
+try{
+ await browser.context.navigate(Bun.pathToFileURL(qml).href);
+ await Bun.sleep(300);
+ const run=s=>browser.context.evaluate(s);
+ const before=await run('({w:code.viewport.width,cw:code.viewport.contentWidth,h:code.viewport.height,ch:code.viewport.contentHeight})');
+ if(before.cw<=before.w||before.ch<=before.h)throw Error(JSON.stringify(before));
+ await run('document.elementFromPoint(200,100).dispatchEvent(new WheelEvent("wheel",{bubbles:true,cancelable:true,clientX:200,clientY:100,deltaX:200,deltaY:0}))');
+ await Bun.sleep(100);
+ if(!(await run('code.viewport.contentX > 0')))throw Error('Horizontal wheel failed');
+ await run('document.elementFromPoint(200,100).dispatchEvent(new WheelEvent("wheel",{bubbles:true,cancelable:true,clientX:200,clientY:100,deltaX:0,deltaY:150}))');
+ await Bun.sleep(100);
+ if(!(await run('code.viewport.contentY > 0')))throw Error('Vertical wheel failed');
+ await run('code.viewport.contentY=0;code.viewport.contentX=code.viewport.contentWidth-code.viewport.width');
+ await Bun.write('/tmp/flea-code-scroll.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+ await run('code.wrap=true');await Bun.sleep(100);
+ if(!await run('code.viewport.contentX===0 && code.viewport.contentWidth===code.viewport.width'))throw Error('Wrap did not reset horizontal lane');
+ await run('code.wrap=false;code.text="short"');await Bun.sleep(100);
+ if(!await run('code.viewport.contentX===0 && code.viewport.contentWidth===code.viewport.width'))throw Error('New file did not reset width');
+ console.log('PASS horizontal/vertical wheel, wrap and new file reset',before);
+}finally{await browser.close();await rm(qml,{force:true})}

package/test/manual-column-scroll.mjs

@@ -0,0 +1,24 @@
+// bun test/manual-column-scroll.mjs: complete Flea preview column, not bare CodeLines.
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';import {tmpdir} from 'node:os';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));const dir=mkdtempSync(join(tmpdir(),'flea-column-scroll-'));
+for(const [key,sub] of [['HOME','home'],['XDG_DATA_HOME','data'],['XDG_CONFIG_HOME','config'],['XDG_CACHE_HOME','cache']]){process.env[key]=join(dir,sub);mkdirSync(process.env[key])}
+process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+await Bun.write(join(dir,'long.txt'),'x'.repeat(512)+'/system/bin/linker64\n'+Array.from({length:200},(_,i)=>'line '+i).join('\n'));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const qml=join(repo,'ui/boot/.column-scroll-'+process.pid+'.qml');
+await Bun.write(qml,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow {id:win;width:900;height:600;Loader{anchors.fill:parent;Component.onCompleted:setSource("${Bun.pathToFileURL(join(repo,'ui/WindowBody.qml')).href}");onLoaded:{item.host=win;globalThis.body=item}}}`);
+const browser=await createBrowser({spareRenderer:false});const run=s=>browser.context.evaluate(s);
+const wait=async s=>{for(let i=0;i<150;i++){if(await run(s))return;await Bun.sleep(100)}throw Error('Timeout '+s)};
+try{
+ await browser.context.navigate(Bun.pathToFileURL(qml).href);
+ await wait('!!globalThis.body && !body.currentPane.listInFlight');
+ await run('body.currentPane.viewMode="columns"');await Bun.sleep(500);await run('body.currentPane.setCursor(body.currentPane.rows.findIndex(r=>r.n==="long.txt"))');
+ await wait('!!body.currentPane.columnsArea?.previewColumn?.linesItem?.code?.firstScreen');
+ await run('globalThis.col=body.currentPane.columnsArea.previewColumn;globalThis.v=col.linesItem.viewport');
+ const rect=await run('(()=>{const r=__qmlRuntime.element(col.frameItem).getBoundingClientRect();return {x:r.x+r.width/2,y:r.y+r.height/2}})()');
+ const wheel=async(dx,dy)=>{await run(`document.elementFromPoint(${rect.x},${rect.y}).dispatchEvent(new WheelEvent("wheel",{bubbles:true,cancelable:true,clientX:${rect.x},clientY:${rect.y},deltaX:${dx},deltaY:${dy}}))`);await Bun.sleep(200)};
+ await wheel(180,0);if(!await run('v.contentX>0'))throw Error('Column horizontal wheel failed');
+ await wheel(0,100);await wait('v.contentY>0');
+ console.log('PASS complete preview column horizontal and vertical wheel',await run('({x:v.contentX,y:v.contentY,cw:v.contentWidth,ch:v.contentHeight})'));
+}finally{await browser.close();rmSync(qml,{force:true});rmSync(dir,{recursive:true,force:true})}

package/test/manual-compare-ui.mjs

@@ -0,0 +1,20 @@
+// Actual JS backend -> bunmsh -cc builtin diff -> QML CompareView.
+import {mkdtemp,rm} from 'node:fs/promises';import {join} from 'node:path';import {tmpdir} from 'node:os';
+import {createBrowser} from '../../buninu-browser/lib/headless-shell.js';
+const dir=await mkdtemp(join(tmpdir(),'flea-compare-ui-'));
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const qml=join(repo,'ui/boot/.compare-'+process.pid+'.qml');
+const a=join(dir,'before.txt'),b=join(dir,'after.txt');
+process.env.BUNINU_BUN=process.execPath;
+await Bun.write(a,'first\nold\nlast\n');await Bun.write(b,'first\nnew\nlast\n');
+await Bun.write(qml,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow{width:640;height:480;color:"#171b22";Flea.Backend{id:backend} Flea.CompareView{id:view;anchors.fill:parent;backend:backend;active:true;pathA:${JSON.stringify(a)};pathB:${JSON.stringify(b)};Component.onCompleted:globalThis.comparison=view}}`);
+const browser=await createBrowser({spareRenderer:false});
+try{
+ await browser.context.navigate(Bun.pathToFileURL(qml).href);
+ let state;for(let i=0;i<100;i++){state=await browser.context.evaluate('globalThis.comparison?.answer');if(state)break;await Bun.sleep(100)}
+ if(state!=='diff')throw Error('Compare answer: '+state);
+ const kinds=await browser.context.evaluate('comparison.rows.map(r=>r.kind)');
+ if(!kinds.includes('removed')||!kinds.includes('added'))throw Error(JSON.stringify(kinds));
+ await Bun.write('/tmp/flea-compare.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+ console.log('PASS real backend and QML CompareView',kinds);
+}finally{await browser.close();await rm(qml,{force:true});await rm(dir,{recursive:true,force:true})}

package/test/manual-find-status.mjs

@@ -0,0 +1,37 @@
+// Exercise the real status bar bindings, including completed Find and ordinary lists.
+import {rm} from 'node:fs/promises';
+import {createBrowser} from '../../buninu-browser/lib/headless-shell.js';
+const qml=new URL('../ui/boot/.find-status-'+process.pid+'.qml',import.meta.url);
+process.env.BUNINU_BUN=process.execPath;
+await Bun.write(qml,`import QtQuick
+import Quickshell
+import ".." as Flea
+FloatingWindow {
+ width: 1000; height: 100; color: "#171b22"
+ Flea.StatusBar {
+  id: bar; width: parent.width
+  listingState: "ready"; total: 2
+  searchLine: "2 found in 0.4 s"; searchRunning: false
+  pane: ({
+   selectionVersion: 1, selection: {count: function(){return 0}, indices: function(){return []}},
+   cursorIndex: 0, shown: null, shownTotal: 2, rows: [{n:"sub/完整的 long filename.txt",s:123}],
+   cursorRow: {n:"sub/完整的 long filename.txt",s:123},
+   rowFor: function(i){return this.rows[i]}
+  })
+  Component.onCompleted: globalThis.bar = bar
+ }
+}`);
+const browser=await createBrowser({spareRenderer:false});
+function assert(ok,message){if(!ok)throw Error(message)}
+try{
+ await browser.context.navigate(Bun.pathToFileURL(Bun.fileURLToPath(qml)).href);
+ for(let i=0;i<100;i++){if(await browser.context.evaluate('!!globalThis.bar?.fileNameItem'))break;await Bun.sleep(50)}
+ let state=await browser.context.evaluate('({shown:bar.showFileName,label:bar.fileLabel,count:bar.countText(),visible:bar.fileNameItem?.visible})');
+ assert(state.shown&&state.visible&&state.label.includes('123')&&state.label.endsWith('完整的 long filename.txt'),JSON.stringify(state));
+ assert(state.count==='2 found in 0.4 s',JSON.stringify(state));
+ await browser.context.evaluate('bar.searchRunning=true');
+ assert(await browser.context.evaluate('!bar.showFileName && bar.centreText()===bar.searchLine'),'live progress lost');
+ await browser.context.evaluate('bar.searchRunning=false; bar.searchLine=""');
+ assert(await browser.context.evaluate('bar.showFileName && bar.countText()==="2 items"'),'ordinary listing regressed');
+ console.log('PASS Find filename, file size, completed summary, running progress and ordinary listing');
+}finally{await browser.close();await rm(qml,{force:true})}

package/test/manual-folder-focus.mjs

@@ -0,0 +1,63 @@
+// bun test/manual-terminal-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+await Bun.write(join(dir,'notes.txt'),'line of preview text\n'.repeat(200));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nimport "../js/Tabs.js" as Tabs\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testTabs=Tabs;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+
+ await run('testBody.currentPane.act("newFolder")');
+ await until('testBody.currentPane.renamingIndex>=0 && document.activeElement.tagName==="INPUT"');
+ await browser.context.type('Created Folder');
+ await browser.context.press('Enter');
+ await until('testBody.currentPane.renamingIndex<0 && !testBody.currentPane.listInFlight');
+ await until('testBody.currentPane.activeFocus');
+ await Bun.sleep(300);
+ const before=await run('testBody.currentPane.cursorIndex');
+ await browser.context.press(before>0?'ArrowUp':'ArrowDown');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),before>0?before-1:before+1);
+ console.log('PASS mkdir + rename + ArrowDown');
+ await run('document.activeElement.blur()');
+ const pos=await run('(()=>{const r=__qmlRuntime.element(testBody.currentPane.visibleItemFor(Array.from({length:testBody.currentPane.total},(_,i)=>i).find(i=>testBody.currentPane.rowFor(i)?.n==="notes.txt"))).getBoundingClientRect();return {x:r.x+40,y:r.y+r.height/2}})()');
+ await browser.context.click(pos.x,pos.y);
+ await until('testBody.currentPane.activeFocus');
+ const clicked=await run('testBody.currentPane.cursorIndex');
+ await browser.context.press('ArrowUp');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),clicked-1);
+ console.log('PASS clicking row recovers list focus from BODY');
+ // Empty list space also takes focus, independently of a row TapHandler.
+ const point=async expr=>run(`(()=>{const r=__qmlRuntime.element(${expr}).getBoundingClientRect();return {x:r.x+r.width/2,y:r.bottom-15}})()`);
+ await run('document.activeElement.blur()');
+ const ground=await point('testBody.currentPane.listArea');
+ await browser.context.click(ground.x,ground.y);
+ await until('testBody.currentPane.listArea.activeFocus');
+ console.log('PASS empty listing ground takes focus');
+ await run('document.activeElement.blur()');
+ const rail=await point('testBody.currentPane.sidebar');
+ await browser.context.click(rail.x,rail.y);
+ await until('testBody.currentPane.sidebar.activeFocus');
+ const railIndex=await run('testBody.currentPane.sidebar.cursorIndex');
+ await browser.context.press('ArrowDown');
+ assert.equal(await run('testBody.currentPane.sidebar.cursorIndex'),railIndex+1);
+ console.log('PASS Places empty ground takes focus and arrow keys');
+ await run('testBody.currentPane.focusView="list";for(let i=0;i<testBody.currentPane.total;i++)if(testBody.currentPane.rowFor(i)?.n==="notes.txt")testBody.currentPane.selectOnly(i,0)');
+ await until('!!testBody.currentPane.previewColumnItem?.visible');
+ const preview=await point('testBody.currentPane.previewColumnItem');
+ await run('document.activeElement.blur()');
+ await browser.context.click(preview.x,preview.y);
+ await until('testBody.currentPane.previewColumnItem.activeFocus');
+ console.log('PASS preview ground takes keyboard focus');
+
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}

package/test/manual-html-security.mjs

@@ -0,0 +1,23 @@
+// bun test/manual-html-security.mjs; uses sibling browser, with scripts enabled.
+// The attack only increments a harmless global counter. Never run raw fixtures.
+import {previewHtml,HTML_TAGS} from '../src/html.js';
+import {createBrowser} from '../../buninu-browser/lib/headless-shell.js';
+const probe='globalThis.__htmlProbe=(globalThis.__htmlProbe||0)+1';
+const payloads=[`<img src=x onerror="${probe}">`,`<script>${probe}</script>`,`<svg onload="${probe}"></svg>`,`<iframe srcdoc="<script>${probe}</script>"></iframe>`,`<p onclick="${probe}">click</p>`,'&lt;img src=x onerror=alert(1)&gt;','<!--><img src=x onerror="'+probe+'">'];
+const wrappers=['div','textarea','plaintext','xmp','title','noscript','select','option','table','svg','math','template','script','style','iframe'];
+const inputs=[];
+for(const a of wrappers)for(const b of wrappers)for(const p of payloads)inputs.push(`<${a}><${b}>${p}</${a}></${b}><p>tail</p>`);
+inputs.push('<math><mtext><table><mglyph><style><!--</style><img title="--><img src=x onerror='+probe+'>">');
+const outputs=inputs.map(previewHtml);
+const browser=await createBrowser({spareRenderer:false});
+try{
+ await browser.context.navigate('about:blank');
+ // First prove the harmless probe works in this execution context.
+ await browser.context.evaluate(probe);
+ if(await browser.context.evaluate('globalThis.__htmlProbe')!==1)throw Error('Probe did not execute');
+ await browser.context.evaluate(`globalThis.__htmlProbe=0;globalThis.__bad=[];const allowed=new Set(${JSON.stringify([...HTML_TAGS])});for(const html of ${JSON.stringify(outputs)}){const host=document.createElement('div');host.innerHTML=html;document.body.appendChild(host);for(const el of host.querySelectorAll('*')){if(!allowed.has(el.localName)||el.attributes.length||el.namespaceURI!=='http://www.w3.org/1999/xhtml')__bad.push(el.outerHTML);el.dispatchEvent(new Event('click'));el.dispatchEvent(new Event('error'));el.dispatchEvent(new Event('load'));}host.remove();}`);
+ await Bun.sleep(100);
+ const result=await browser.context.evaluate('({executed:__htmlProbe,bad:__bad})');
+ if(result.executed||result.bad.length)throw Error(JSON.stringify(result));
+ console.log('PASS',outputs.length,'adversarial fragments; no illegal elements/attributes or script execution');
+}finally{await browser.close()}

package/test/manual-html-ui.mjs

@@ -0,0 +1,30 @@
+// bun test/manual-html-ui.mjs; real backend + QML rich-text preview, no external resources.
+import {mkdtemp,rm} from 'node:fs/promises';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import {createBrowser} from '../../buninu-browser/lib/headless-shell.js';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=await mkdtemp(join(tmpdir(),'flea-html-ui-'));
+const qml=join(repo,'ui/boot/.html-check-'+process.pid+'.qml');
+const path=join(dir,'preview.html');
+process.env.BUNINU_BUN=process.execPath;
+await Bun.write(path,'<h1 onclick="globalThis.__htmlProbe=1">HTML preview</h1><div><b>Bold</b> &amp; <i>italic</i><div>Nested div</div></div><textarea><img src=x onerror="globalThis.__htmlProbe=1"></textarea>'+ '<p>Scrollable text</p>'.repeat(80));
+await Bun.write(qml,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow {width:640;height:480;color:"#171b22";Flea.Backend{id:backend} Loader {anchors.fill:parent;Component.onCompleted:setSource("${Bun.pathToFileURL(join(repo,'ui/PreviewHtml.qml')).href}");onLoaded:{item.backend=backend;item.path=${JSON.stringify(path)};item.active=true;globalThis.preview=item}}}`);
+const browser=await createBrowser({spareRenderer:false});
+try{
+ await browser.context.navigate(Bun.pathToFileURL(qml).href);
+ let ready=false;
+ for(let i=0;i<150;i++){ready=await browser.context.evaluate('!!globalThis.preview && preview.contentReady');if(ready)break;await Bun.sleep(100)}
+ if(!ready)throw Error('Preview never ready: '+await browser.context.evaluate('document.body.innerText'));
+ const result=await browser.context.evaluate('({text:document.body.innerText,probe:globalThis.__htmlProbe||0,height:preview.viewport.contentHeight,viewport:preview.viewport.height})');
+ if(!result.text.includes('Nested div')||result.probe||result.height<=result.viewport)throw Error(JSON.stringify(result));
+ await browser.context.evaluate('preview.scrollBy(5)');
+ if(!(await browser.context.evaluate('preview.scrollY > 0')))throw Error('Scroll failed');
+ await browser.context.evaluate('preview.viewport.contentY=0');
+ await Bun.write('/tmp/flea-html-preview.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+ await browser.context.evaluate('preview.width=240');
+ const boxes=await browser.context.evaluate(`(()=>{const e=document.querySelector('h1'),p=document.querySelector('p');return {heading:e.getBoundingClientRect(),paragraph:p.getBoundingClientRect(),content:preview.viewport.contentHeight}})()`);
+ if(boxes.paragraph.top<boxes.heading.bottom)throw Error('Heading overlaps paragraph: '+JSON.stringify(boxes));
+ await Bun.write('/tmp/flea-html-preview-narrow.png',Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+ console.log('PASS backend HTML, nested rich text, literal attack text and scrolling',result.height,result.viewport);
+}finally{await browser.close();await rm(qml,{force:true});await rm(dir,{recursive:true,force:true})}

package/test/manual-syntax-preview.mjs

@@ -0,0 +1,26 @@
+// Run: bun test/manual-syntax-preview.mjs [path/to/jsmdcui]
+// Uses that checkout's runtime/syntax definitions and syntax-parity samples.
+import {resolve,join} from 'node:path';
+const base=resolve(process.argv[2] || new URL('../../jsmdcui',import.meta.url).pathname);
+const {SyntaxDefinition,parseHeaderYaml,detectSyntax}=await import(Bun.pathToFileURL(join(base,'src/highlight/parser.js')).href);
+import {code} from '../src/code.js';
+import {runsOf} from '../src/highlight.js';
+import {tmpdir} from 'node:os';
+import {mkdtempSync,writeFileSync,rmSync} from 'node:fs';
+const defs=[];
+for(const file of new Bun.Glob('*.yaml').scanSync(base+'/runtime/syntax')) {const text=await Bun.file(base+'/runtime/syntax/'+file).text(),src=Bun.YAML.parse(text);defs.push({file,def:new SyntaxDefinition(parseHeaderYaml(src),src,text)});}
+const dir=mkdtempSync(join(tmpdir(),'flea-syntax-'));const results=[];
+const words=new Set(['Dockerfile','Containerfile','.bashrc','Makefile','CMakeLists.txt','README.md','Cargo.lock','sample.dats','sample.f90','sample.ebuild','sample.eclass','gitconfig','git-rebase-todo','go.mod','meson.build','sample.mm','sample.pl','sample.ps1','Xresources','sample.yml','sample.zig','sample.zc']);
+for(const {def} of defs) for(const w of (def.header.filename||'').match(/[A-Za-z0-9_-]+/g)||[]) {words.add(w);words.add('.'+w);words.add('sample.'+w);words.add(w+'.conf');}
+let index=0;
+try {await Promise.all(Array.from({length:4},async()=>{for(;;){const i=index++;if(i>=defs.length)return;const {file,def}=defs[i];if(/^html[45]?$/.test(def.filetype))continue;
+ const sample=Bun.file(base+'/tests/syntax-parity/samples/'+file.replace(/yaml$/,'txt'));if(!await sample.exists()){results.push({file,error:'missing sample'});continue;}
+ const text=await sample.text();
+ const child=Bun.spawn([process.execPath,join(base,'src/index.js'),'--cat','--edit','-filetype',def.filetype,sample.name],{stdout:'pipe',stderr:'pipe'});
+ const [ansi,stderr,exit]=await Promise.all([new Response(child.stdout).text(),new Response(child.stderr).text(),child.exited]);
+ const explicitColour=exit===0 && ansi.split('\n').some(l=>runsOf(l).some((v,i)=>i%2===0&&v!==0));
+ const path=[...words].find(p=>def.header.matchFileName(p)&&detectSyntax(defs.map(x=>x.def),{path:p,firstLine:text.split('\n')[0],lines:text.split('\n').slice(0,50)})?.filetype===def.filetype);
+ if(!path){results.push({file,explicitColour,error:'no automatic filename witness',pattern:def.header.filename});continue;}
+ const target=dir+'/'+i;await Bun.write(target+'/'+path,text);const r=await code({path:target+'/'+path});results.push({file,explicitColour,path,state:r.state,lines:r.total});
+}}));}finally{rmSync(dir,{recursive:true,force:true});}
+results.sort((a,b)=>a.file.localeCompare(b.file));await Bun.write(join(tmpdir(),'flea-syntax-results.json'),JSON.stringify(results,null,2));console.log(JSON.stringify({total:results.length,explicitColour:results.filter(r=>r.explicitColour).length,styled:results.filter(r=>r.state==='styled').length,other:results.filter(r=>r.state!=='styled')},null,2));

package/test/manual-terminal-lifecycle.mjs

@@ -0,0 +1,42 @@
+// bun test/manual-terminal-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+ await run('testBody.currentPane.openTerminal()');
+ await until('!!testBody.currentPane.terminalId');
+ await until('Object.values(terminalService.tabs).some(t=>t.url?.includes("reconnect-token"))');
+ const one=await run('Object.values(terminalService.tabs)[0].url');
+ await run('testBody.currentPane.openTerminal()');
+ await until('Object.values(terminalService.tabs).length===2 && Object.values(terminalService.tabs).every(t=>t.url?.includes("reconnect-token"))');
+ const urls=await run('Object.values(terminalService.tabs).map(t=>t.url)');
+ assert.equal(new URL(urls[0]).host,new URL(urls[1]).host);assert.notEqual(urls[0],urls[1]);
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),3);
+ console.log('PASS two terminal tabs, shared listener, distinct sessions',new URL(one).port);
+ await run('for (const id of Object.keys(terminalService.tabs)) terminalService.release(id)');
+ await until('!terminalService.stopping && !terminalService.process.running');
+ let closed=false;try{await fetch(one)}catch{closed=true}assert(closed);
+ console.log('PASS final terminal closes shared listener');
+ await run('terminalService.acquire(testBody.currentPane.path)');
+ await until('Object.values(terminalService.tabs).some(t=>t.url)');
+ const restarted=await run('Object.values(terminalService.tabs)[0].url');
+ assert.equal((await fetch(restarted)).status,200);
+ await run('for (const id of Object.keys(terminalService.tabs)) terminalService.release(id); terminalService.acquire(testBody.currentPane.path)');
+ await until('!terminalService.stopping && Object.values(terminalService.tabs).some(t=>t.url)');
+ console.log('PASS reopen during shutdown starts a fresh listener');
+ await run('for (const id of Object.keys(terminalService.tabs)) terminalService.release(id)');
+ await until('!terminalService.stopping && !terminalService.process.running');
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}

package/test/manual-terminal-navigation.mjs

@@ -0,0 +1,48 @@
+// bun test/manual-terminal-ui.mjs (requires the sibling buninu-browser checkout).
+import {mkdtempSync,mkdirSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import assert from 'node:assert/strict';
+const repo=Bun.fileURLToPath(new URL('../',import.meta.url));
+const dir=mkdtempSync(join(tmpdir(),'flea-terminal-ui-'));
+process.env.XDG_DATA_HOME=join(dir,'data');process.env.XDG_CONFIG_HOME=join(dir,'config');process.env.XDG_CACHE_HOME=join(dir,'cache');process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.terminal-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nimport "../js/Tabs.js" as Tabs\nFloatingWindow { id: win; width:900; height:600; Loader {anchors.fill:parent; source:"../WindowBody.qml";onLoaded:{item.host=win;globalThis.testTabs=Tabs;globalThis.testBody=item;globalThis.terminalService=Flea.TerminalService}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+const until=async(s)=>{for(let i=0;i<200;i++){if(await run(s))return;await Bun.sleep(100);}throw Error('UI timeout '+s+' '+await run('document.body.innerText.slice(-2500)'));};
+try {
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ await until('!!globalThis.testBody && !testBody.currentPane.listInFlight');
+ await run('testBody.currentPane.openTerminal()');
+ await until('!!testBody.currentPane.terminalId');
+ await until('Object.values(terminalService.tabs).some(t=>t.url?.includes("reconnect-token"))');
+ const one=await run('Object.values(terminalService.tabs)[0].url');
+
+
+
+ await until('!!document.querySelector("canvas")');
+ await browser.context.click(400,100);
+ await run('testTabs.selectAt(testBody.currentPane,0)');
+ await Bun.sleep(100);
+ console.log('ordinary focus',await run('({focus:testBody.currentPane.activeFocus,active:document.activeElement.tagName,id:testBody.currentPane.terminalId})'));
+ const cursor=await run('testBody.currentPane.cursorIndex');
+ await browser.context.press('ArrowDown');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),cursor+1,'ArrowDown must reach the ordinary list');
+ await browser.context.press('ArrowUp');
+ assert.equal(await run('testBody.currentPane.cursorIndex'),cursor);
+ await browser.context.press('t');
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),3,'ordinary t must work after terminal switch');
+ await browser.context.press('t',{modifiers:2,code:'KeyT'});
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),4,'Ctrl+T must open another terminal');
+ console.log('PASS terminal -> ordinary -> arrows -> t -> Ctrl+T');
+ await run('testTabs.closeAt(testBody.currentPane,testBody.currentPane.tabs.index)');
+ await Bun.sleep(100);
+ assert.equal(await run('testBody.currentPane.activeFocus'),true,'closing terminal returns focus');
+ await browser.context.press('t',{modifiers:2,code:'KeyT'});
+ assert.equal(await run('testBody.currentPane.tabs.items.length'),4);
+ console.log('PASS close terminal -> ordinary -> Ctrl+T');
+
+}finally{await browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true});}