flea-qml 0.0.0-stage → 0.1.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-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-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-trash-ui.mjs

@@ -0,0 +1,86 @@
+// Run: bun test/manual-trash-ui.mjs (requires ../buninu-browser). Uses temporary fixtures only.
+import {mkdtempSync,mkdirSync,writeFileSync,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-trash-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.HOME=dir;process.env.FLEA_PATH=dir;process.env.BUNINU_BUN=process.execPath;
+for(const p of ['data','config','cache'])mkdirSync(join(dir,p));
+const {trashOne}=await import('../src/trash.js');
+writeFileSync(join(dir,'preview.txt'),'HELLO TRASH PREVIEW\nline two');trashOne(join(dir,'preview.txt'));
+writeFileSync(join(dir,'other.txt'),'SECOND');trashOne(join(dir,'other.txt'));
+mkdirSync(join(dir,'folder'));writeFileSync(join(dir,'folder','child'),'child');trashOne(join(dir,'folder'));
+const {createBrowser}=await import('../../buninu-browser/lib/headless-shell.js');
+const file=join(repo,'ui/boot/.trash-check-'+process.pid+'.qml');
+await Bun.write(file,`import QtQuick\nimport Quickshell\nimport ".." as Flea\nFloatingWindow { id: win; width:900; height:600; Loader {id:body; anchors.fill:parent; Component.onCompleted:{globalThis.testLoader=body;setSource("${Bun.pathToFileURL(join(repo,"ui/WindowBody.qml")).href}")} onStatusChanged:console.log("TESTLOADER",status) ; onLoaded:{item.host=win;globalThis.testBody=item}} }`);
+const browser=await createBrowser({spareRenderer:false});
+const run=s=>browser.context.evaluate(s);
+try {
+ await browser.context.addInitScript(`globalThis.compileErrors=[];const compile=__qmlHost.compile;__qmlHost.compile=(...a)=>{try{return compile(...a)}catch(e){compileErrors.push(String(e));throw e}}`);
+ await browser.context.navigate(Bun.pathToFileURL(file).href);
+ console.log('loaded',await run('document.body.innerText.slice(0,5000)'));
+ for(let i=0;i<30;i++){if(await run('!!globalThis.testBody && !testBody.currentPane.listInFlight'))break;await Bun.sleep(100)}
+ if(!await run('!!globalThis.testBody'))throw Error('testBody missing '+JSON.stringify(await run('({status:globalThis.testLoader?.status,source:globalThis.testLoader?.source,text:document.body.innerText,errors:globalThis.compileErrors})'))) ;
+ console.log('initial',await run('({text:document.body.innerText.slice(0,150),mode:testBody.currentPane.recentMode})'));
+ for(const address of ['trash:/','trash://','trash:///']) {
+  if(await run('testBody.currentPane.recentMode === "trash"')) {
+   await run('testBody.currentPane.closeRecent()');
+   for(let i=0;i<150;i++){if(await run('!testBody.currentPane.listInFlight'))break;await Bun.sleep(100)}
+  }
+  await run(`testBody.currentPane.chromeBar.startEdit();testBody.currentPane.chromeBar.pathField.text=${JSON.stringify(address)};testBody.currentPane.chromeBar.commitEdit()`);
+  for(let i=0;i<150;i++){if(await run('!testBody.currentPane.listInFlight'))break;await Bun.sleep(100)}
+  if(!await run('testBody.currentPane.recentMode === "trash" && testBody.currentPane.path === "/" && testBody.currentPane.chromeBar.path === "trash:///"'))throw Error('Trash address failed: '+address);
+ }
+ await run('testBody.currentPane.chromeBar.startEdit()');
+ if(await run('testBody.currentPane.chromeBar.editText')!=='trash:///')throw Error('Trash edit address acquired an extra slash');
+ await run('testBody.currentPane.chromeBar.closeEdit()');
+ console.log('PASS all Trash address aliases, display and unchanged backing path');
+ const paths=await run('testBody.currentPane.rows.map(r=>r.trash.original)');
+ if(paths.length!==3 || paths.some(p=>!p.startsWith(dir+'/')))throw Error('External trash detected; refusing mutation');
+ console.log('trash',await run('({text:document.body.innerText,mode:testBody.currentPane.recentMode,rows:testBody.currentPane.total,cursor:testBody.currentPane.cursorRow})'));
+ await run('testBody.currentPane.setCursor(testBody.currentPane.rows.findIndex(r=>r.n.endsWith("preview.txt")))');
+ if(await run('testBody.currentPane.statusBar.selectedName')!=='preview.txt')throw Error('Trash status filename is not the original name');
+ if(!await run('testBody.currentPane.statusBar.fileNameItem.visible && testBody.currentPane.statusBar.fileNameItem.width > 0'))throw Error('Status filename has no visible space');
+ console.log('PASS status filename uses the original Trash name');
+ // Exercise only the presentation component with a name wider than the window;
+ // keep the actual fixture paths and operation identities untouched.
+ await run('testBody.currentPane.statusBar.fileNameItem.name="完整檔案名稱-".repeat(40)+".txt"');
+ await Bun.sleep(100);
+ if(!await run('testBody.currentPane.statusBar.fileNameItem.contentWidth > testBody.currentPane.statusBar.fileNameItem.width'))throw Error('Long status filename cannot scroll');
+ await run('testBody.currentPane.statusBar.fileNameItem.contentX=testBody.currentPane.statusBar.fileNameItem.contentWidth-testBody.currentPane.statusBar.fileNameItem.width');
+ if(!await run('testBody.currentPane.statusBar.fileNameItem.contentX > 0'))throw Error('Long status filename did not scroll');
+ if(process.env.FLEA_STATUS_SCREENSHOT)await Bun.write(process.env.FLEA_STATUS_SCREENSHOT,Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+ await run('testBody.currentPane.statusBar.fileNameItem.name=testBody.currentPane.statusBar.fileLabel');
+ if(await run('testBody.currentPane.statusBar.fileNameItem.contentX')!==0)throw Error('New filename did not reset scrolling');
+ console.log('PASS long status filename scrolling and reset');
+ await run('testBody.currentPane.act("preview")');await Bun.sleep(2000);
+ if(!await run('testBody.quickLookActive && document.body.innerText.includes("HELLO TRASH PREVIEW")'))throw Error('preview missing');
+ if(process.env.FLEA_TRASH_SCREENSHOT)await Bun.write(process.env.FLEA_TRASH_SCREENSHOT,Buffer.from(await browser.context.screenshot({format:'png'}),'base64'));
+ console.log('preview',await run('({active:testBody.quickLookActive,text:document.body.innerText.slice(-900)})'));
+ await run('testBody.currentPane.quickLook().close()');
+ await run('testBody.currentPane.act("filter");testBody.currentPane.filterQuery="preview"');
+ await Bun.sleep(150);
+ if(await run('testBody.currentPane.shown.length')!==1)throw Error('filter failed');
+ await run('testBody.currentPane.filterQuery="";testBody.currentPane.filterTyping=false');
+ const wait=async predicate=>{for(let i=0;i<200;i++){if(await run(predicate))return;await Bun.sleep(50)}throw Error('Timed out: '+predicate)};
+ await run('testBody.currentPane.open(testBody.currentPane.join("/",testBody.currentPane.rows.find(r=>r.d).n))');
+ await wait('!testBody.currentPane.listInFlight && testBody.currentPane.recentMode===""');
+ await run('testBody.currentPane.goBack()');
+ await wait('!testBody.currentPane.listInFlight && testBody.currentPane.recentMode==="trash"');
+ console.log('PASS filter and directory Back');
+ await run('testBody.currentPane.setCursor(testBody.currentPane.rows.findIndex(r=>r.n.endsWith("preview.txt")));testBody.currentPane.trash.action("deletePermanently")');
+ await wait('testBody.currentPane.trash.confirmationOpen');
+ await run('testBody.currentPane.trash.confirmation.cancel()');
+ await wait('!testBody.currentPane.trash.busy');
+ await run('testBody.currentPane.trash.action("restoreTrashSelection")');
+ await wait('!testBody.currentPane.trash.busy && !testBody.currentPane.listInFlight && testBody.currentPane.total===2');
+ if(!await Bun.file(join(dir,'preview.txt')).exists())throw Error('restore missing');
+ console.log('PASS cancel deletion and restore selected');
+ await run('testBody.currentPane.trash.action("emptyTrash")');
+ await wait('testBody.currentPane.trash.confirmationOpen');
+ // Opening the review is safe; never activate Empty Trash in a test, because
+ // mount-local trashes can exist outside the isolated HOME/XDG directories.
+ await run('testBody.currentPane.trash.confirmation.cancel()');
+ await wait('!testBody.currentPane.trash.busy');
+ console.log('PASS Empty Trash review and cancellation');
+}finally{browser.close();rmSync(file,{force:true});rmSync(dir,{recursive:true,force:true})}

package/test/markdown-diagrams.test.js

@@ -0,0 +1,93 @@
+// Mermaid diagrams in the Markdown previews: fences held out of the page and drawn by src/figure.js
+// (Pele in a Bun Worker), embedded as SVG pictures, and their source kept with a reason when not.
+import { afterAll, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DIAGRAMS_PER_PAGE, drawDiagrams, holdFormulas, markdownHtml, markdownPage } from "../src/markdown-html.js";
+import { figureTheme, renderDiagram, stopFigures } from "../src/figure.js";
+
+const folder = mkdtempSync(join(tmpdir(), "flea-diagrams-"));
+afterAll(() => { stopFigures(); rmSync(folder, { recursive: true, force: true }); });
+
+const FLOW = "flowchart TD\n  A[開始 😀] --> B[結束]";
+const pictures = (html) => [...html.matchAll(/<div class="diagram"><img alt="Mermaid diagram" src="data:image\/svg\+xml;base64,([^"]+)"><\/div>/g)]
+  .map((match) => Buffer.from(match[1], "base64").toString());
+
+test("Mermaid fences are held as the block view picks them, and other code stays code", () => {
+  const source = [
+    "```mermaid", "flowchart TD", "  A --> B", "```",
+    "~~~ Mermaid title", "pie", "~~~",
+    "  ```mermaid", "  sequenceDiagram", "    A->>B: hi", "  ```",
+    "```js", "const x = 1;", "```",
+    "```mermaid`", "not a fence opener", "```",
+    "$x$ and `$y$`",
+    "```mermaid", "flowchart LR", "  unclosed --> end",
+  ].join("\n");
+  const { text, diagrams, formulas } = holdFormulas(source);
+  expect(diagrams).toEqual(["flowchart TD\n  A --> B", "pie", "sequenceDiagram\n  A->>B: hi", "flowchart LR\n  unclosed --> end"]);
+  expect(text).toContain("```js\nconst x = 1;\n```");
+  expect(text).not.toContain("flowchart");
+  expect(formulas).toEqual([{ tex: "x", display: false }]);
+});
+
+test("a drawn diagram becomes a picture; a failed one keeps its source and says why", () => {
+  const svg = '<svg xmlns="http://www.w3.org/2000/svg" width="10" height="10"><text>中文</text></svg>';
+  const source = "# T\n\n```mermaid\nA\n```\n\n```mermaid\nB & <b>\n```\n\n```mermaid\nC\n```\n";
+  const html = markdownPage(source, folder, {}, [{ svg }, { error: "Parse error <here>" }]);
+  expect(pictures(html)).toEqual([svg]);
+  expect(html).toContain("<pre><code>B &amp; &lt;b&gt;</code></pre><p class=\"diagram-error\">Diagram not drawn · Parse error &lt;here&gt;</p>");
+  // A page built without drawing (no answer for the fence) shows the plain source.
+  expect(html).toContain("<pre><code>C</code></pre>");
+  expect(html).not.toMatch(/[]|<p><div|<script/);
+});
+
+test("diagrams share the pictures' budget", () => {
+  const big = `<svg xmlns="http://www.w3.org/2000/svg">${"x".repeat((1 << 20) + 1)}</svg>`;
+  const html = markdownPage("```mermaid\nA\n```\n", folder, {}, [{ svg: big }]);
+  expect(pictures(html)).toEqual([]);
+  expect(html).toContain("Diagram not drawn · over the page's picture budget");
+});
+
+test("the HTML preview draws Chinese and emoji labels, and the page stays passive", async () => {
+  const path = join(folder, "doc.md");
+  writeFileSync(path, `# 圖\n\n\`\`\`mermaid\n${FLOW}\n\`\`\`\n\n\`\`\`mermaid\nflowchart TD\n  A -->\n\`\`\`\n`);
+  const answer = await markdownHtml({ path, token: 3, slot: "s", theme: { foreground: "#c0caf5", background: "#101315" } });
+  expect(answer).toMatchObject({ t: "markdownhtml", token: 3, slot: "s", state: "ready" });
+  const [svg] = pictures(answer.html);
+  expect(svg).toContain("開始 😀");
+  expect(svg).toContain("#c0caf5");
+  expect(svg).not.toMatch(/<script|<foreignObject|\son\w+=/i);
+  expect(answer.html).toMatch(/Diagram not drawn · Parse error on line 3: Expecting/);
+  expect(answer.html).not.toMatch(/<script/i);
+});
+
+test(`at most ${DIAGRAMS_PER_PAGE} diagrams are drawn for one page`, async () => {
+  const source = Array.from({ length: DIAGRAMS_PER_PAGE + 1 }, () => "```mermaid\nflowchart TD\n  A --> B\n```").join("\n\n");
+  const drawn = await drawDiagrams(source);
+  expect(drawn.slice(0, DIAGRAMS_PER_PAGE).every((answer) => answer.svg)).toBe(true);
+  expect(drawn.at(-1)).toEqual({ error: `more than ${DIAGRAMS_PER_PAGE} diagrams on the page` });
+});
+
+test("renderDiagram caches, reports errors, and recovers from a deadline", async () => {
+  const first = await renderDiagram(FLOW);
+  expect(first.svg).toContain("結束");
+  expect(await renderDiagram(FLOW)).toBe(first);
+  expect((await renderDiagram("flowchart TD\n  A -->")).error).toMatch(/^Parse error on line 3: Expecting/);
+  expect(await renderDiagram("  ")).toEqual({ error: "empty diagram" });
+  expect(await renderDiagram("x".repeat(32769))).toEqual({ error: "diagram over 32 KiB" });
+  const slow = "flowchart LR\n" + Array.from({ length: 300 }, (_, i) => `  N${i} --> N${(i * 7 + 3) % 300}`).join("\n");
+  expect(await renderDiagram(slow, {}, { timeout: 1 })).toEqual({ error: "diagram took over 0.001 s" });
+  // The stuck Worker was terminated; the next diagram starts a fresh one.
+  expect((await renderDiagram("sequenceDiagram\n  甲->>乙: 你好")).svg).toContain("你好");
+});
+
+test("figureTheme keeps colours, a plain font name and whole advance tables, and dates a Gantt chart", () => {
+  const advances = Array.from({ length: 95 }, () => 500);
+  const theme = figureTheme({ fg: '"><script>', background: "#101315", font: "Noto Sans CJK TC", advances, boldAdvances: [1, 2] },
+    "gantt\n  title 計畫", new Date(2026, 10, 15, 23));
+  expect(theme).toMatchObject({ fg: "#d8dee9", bg: "#101315", font: "Noto Sans CJK TC", advances, boldAdvances: [] });
+  expect(theme.today).toBe(Date.UTC(2026, 10, 15, 12));
+  expect(figureTheme({ font: 'x" onload="y' }).font).toBe("sans-serif");
+  expect(figureTheme({}, "flowchart TD").today).toBeUndefined();
+});