buninu-linux 0.15.58 → 0.17.60

package/initramfs/buninu/apps/jsgotty/tests/reconnect-modes.test.js

@@ -0,0 +1,166 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { TerminalModeTracker, modeTransition } = require('../terminal-modes.js');
+
+const source = fs.readFileSync(path.join(__dirname, '../static/js/gotty.js'), 'utf8');
+const methods = source.slice(source.indexOf('          enqueueTerminal(task)'), source.indexOf('          setDisconnected(e)'));
+
+function feed(tracker, ...chunks) {
+  for (const chunk of chunks) tracker.consume(Buffer.from(chunk, 'latin1'));
+  return tracker.snapshot();
+}
+
+function client({ alternate = false, dec = {}, mouse = 'NONE', encoding = 'DEFAULT', cursorHidden = false } = {}) {
+  const Wrapper = vm.runInNewContext(`(class {${methods}})`);
+  const w = new Wrapper();
+  const writes = [];
+  const defaults = { applicationCursorKeys: false, applicationKeypad: false, bracketedPasteMode: false,
+    origin: false, reverseWraparound: false, sendFocus: false, wraparound: true };
+  w.term = {
+    _core: { coreService: { decPrivateModes: { ...defaults, ...dec }, isCursorHidden: cursorHidden },
+      coreMouseService: { activeProtocol: mouse, activeEncoding: encoding } },
+    buffer: { active: { type: alternate ? 'alternate' : 'normal' } },
+    write: (s, callback) => { if (s) writes.push(s); callback?.(); },
+  };
+  w.kittyKeyboard = { states: { normal: { flags: 0, stack: [] }, alternate: { flags: 0, stack: [] } } };
+  return { w, writes };
+}
+
+test('tracker follows DEC, mouse, alternate screen and kitty keyboard modes', () => {
+  const state = feed(new TerminalModeTracker(),
+    'hi\x1b[?1049h\x1b[?1;2004h\x1b=\x1b[?25l',
+    '\x1b[?1002h\x1b[?10', '06h', // split across chunks
+    '\x1b[>1u\x1b[>11u\x1b]0;title \x1b[?2004l\x07');
+  assert.equal(state.alternate, true);
+  assert.equal(state.dec.applicationCursorKeys, true);
+  assert.equal(state.dec.bracketedPasteMode, true, 'OSC payload is not parsed as CSI');
+  assert.equal(state.dec.applicationKeypad, true);
+  assert.equal(state.cursorHidden, true);
+  assert.equal(state.mouse, 'DRAG');
+  assert.equal(state.encoding, 'SGR');
+  assert.deepEqual(state.kitty.alternate, { flags: 11, stack: [0, 1] });
+  assert.deepEqual(state.kitty.normal, { flags: 0, stack: [] });
+});
+
+test('tracker handles mode resets, kitty pop/set and RIS', () => {
+  const tracker = new TerminalModeTracker();
+  let state = feed(tracker, '\x1b[?1003h\x1b[?1006h\x1b[?1000l\x1b[?1006l\x1b[>1u\x1b[=8;2u\x1b[<u');
+  assert.equal(state.mouse, 'NONE');
+  assert.equal(state.encoding, 'DEFAULT');
+  assert.equal(state.kitty.normal.flags, 0);
+  state = feed(tracker, '\x1b[?1049h\x1b[?2004h\x1b[?1002h\x1b[!p');
+  assert.equal(state.dec.bracketedPasteMode, false, 'DECSTR resets DEC modes');
+  assert.equal(state.alternate, true, 'DECSTR keeps the active screen');
+  assert.equal(state.mouse, 'DRAG', 'DECSTR keeps mouse reporting');
+  state = feed(tracker, '\x1bc');
+  assert.deepEqual(state, new TerminalModeTracker().snapshot());
+});
+
+test('fresh client gets the full state restored', () => {
+  const state = feed(new TerminalModeTracker(), '\x1b[?1049h\x1b[?2004h\x1b[?1002h\x1b[?1006h\x1b[?25l\x1b[>11u');
+  const { w, writes } = client();
+  w.applySessionModes(state);
+  assert.equal(writes.length, 1);
+  for (const seq of ['\x1b[?1049h', '\x1b[?2004h', '\x1b[?1002h', '\x1b[?1006h', '\x1b[?25l'])
+    assert.ok(writes[0].includes(seq), JSON.stringify(seq));
+  assert.equal(w.kittyKeyboard.states.alternate.flags, 11);
+});
+
+test('browser masks kitty flags it does not implement', () => {
+  const { w } = client();
+  w.applySessionModes(feed(new TerminalModeTracker(), '\x1b[>31u\x1b[>31u'));
+  assert.equal(JSON.stringify(w.kittyKeyboard.states.normal), JSON.stringify({ flags: 11, stack: [0, 11] }));
+});
+
+test('socket-only reconnect with matching xterm state writes nothing', () => {
+  const state = feed(new TerminalModeTracker(), '\x1b[?1049h\x1b[?6h\x1b[?2004h\x1b[?1002h\x1b[?1006h\x1b[>1u\x1b[>11u');
+  const { w, writes } = client({ alternate: true, dec: { origin: true, bracketedPasteMode: true }, mouse: 'DRAG', encoding: 'SGR' });
+  w.applySessionModes(state);
+  assert.equal(writes.length, 0, 'no DECOM cursor homing or 1049 cursor save');
+  w.applySessionModes(state);
+  assert.deepEqual(JSON.parse(JSON.stringify(w.kittyKeyboard.states.alternate)), { flags: 11, stack: [0, 1] }, 'push stack does not grow');
+});
+
+test('stale client modes are turned off when the program disabled them while disconnected', () => {
+  const state = new TerminalModeTracker().snapshot();
+  const { w, writes } = client({ alternate: true, dec: { bracketedPasteMode: true }, mouse: 'ANY', encoding: 'SGR' });
+  w.applySessionModes(state);
+  assert.equal(writes.length, 1);
+  for (const seq of ['\x1b[?1049l', '\x1b[?2004l', '\x1b[?1000l', '\x1b[?1006l'])
+    assert.ok(writes[0].includes(seq), JSON.stringify(seq));
+});
+
+test('transport disconnect and reconnect clear held keys without resetting negotiation', () => {
+  const start = source.indexOf('          reset() {\n            // Reconnecting');
+  const reset = source.slice(start, source.indexOf('          close() {', start));
+  assert.match(reset, /clearHeld\(false\)/);
+  assert.doesNotMatch(reset, /kittyKeyboard.reset/);
+  assert.match(source, /setDisconnected\(e\) \{\s*if \(e\) this.kittyKeyboard.clearHeld\(false\)/);
+});
+
+const sessions = {
+  vim: '\x1b[?1049h\x1b[?1h\x1b=\x1b[?2004h\x1b[?1002h\x1b[?1006h\x1b[?25l',
+  kittyBothScreens: '\x1b[>1u\x1b[?1049h\x1b[>31u\x1b[>3u\x1b[?1003h\x1b[?1016h',
+  kittySetThenPush: '\x1b[=5;1u\x1b[>8u\x1b[?1004h\x1b[?6h',
+};
+
+for (const [name, output] of Object.entries(sessions)) {
+  test(`CLI resume and cleanup round-trip: ${name}`, () => {
+    const target = feed(new TerminalModeTracker(), output);
+    const local = new TerminalModeTracker();
+    assert.deepEqual(feed(local, modeTransition(local.snapshot(), target)), target, 'fresh terminal reaches PTY state');
+    assert.equal(modeTransition(local.snapshot(), target), '', 'nothing left to send once in sync');
+    assert.deepEqual(feed(local, modeTransition(local.snapshot())), new TerminalModeTracker().snapshot(), 'cleanup returns to defaults');
+  });
+}
+
+test('kitty flags are kept unmasked for terminals that support all of them', () => {
+  assert.equal(feed(new TerminalModeTracker(), '\x1b[>31u').kitty.normal.flags, 31);
+});
+
+test('incremental Kitty restoration preserves a non-default parent stack', () => {
+  const local = new TerminalModeTracker();
+  feed(local, '\x1b[=1u\x1b[>11u');
+  const parent = local.snapshot();
+  const remote = feed(new TerminalModeTracker(), '\x1b[>3u\x1b[>9u');
+  const attach = modeTransition(parent, remote);
+  assert.doesNotMatch(attach, /<100u/);
+  assert.deepEqual(feed(local, attach), remote);
+  assert.deepEqual(feed(local, modeTransition(local.snapshot(), parent)), parent);
+});
+
+test('unknown original modes are not replaced with guessed defaults on cleanup', () => {
+  const unknown = new TerminalModeTracker().snapshot();
+  for (const key of Object.keys(unknown.dec)) unknown.dec[key] = null;
+  for (const key of ['alternate','cursorHidden','mouse','encoding']) unknown[key] = null;
+  unknown.kitty.normal.flags = unknown.kitty.alternate.flags = null;
+  assert.equal(modeTransition(feed(new TerminalModeTracker(), '\x1b[?1049h\x1b[>11u'), unknown), '');
+});
+
+test('hidden Kitty restoration is negotiated and never toggles the screen',()=>{
+ for(const alternate of [false,true]){
+  const local=new TerminalModeTracker();if(alternate)feed(local,'\x1b[?1049h');
+  const target=local.snapshot(),hidden=alternate?'normal':'alternate';
+  target.kitty[hidden]={flags:9,stack:[0,1]};
+  assert.equal(modeTransition(local.snapshot(),target),'');
+  const sequence=modeTransition(local.snapshot(),target,{kittyRestore:true});
+  assert.doesNotMatch(sequence,/\[\?(?:47|1047|1049)[hl]/);
+  // Every-byte fragmentation must be handled by intermediate server trackers.
+  for(const byte of Buffer.from(sequence))local.consume(Buffer.from([byte]));
+  assert.deepEqual(local.snapshot(),target);
+ }
+});
+test('Kitty restore tracker rejects malformed or unrelated string commands',()=>{
+ const t=new TerminalModeTracker(),before=t.snapshot();
+ for(const payload of [
+  '\x1b]777;jsgotty-kitty-v1;normal;32;0\x07',
+  '\x1b]777;jsgotty-kitty-v1;normal;1;'+Array(33).fill('0').join(',')+'\x07',
+  '\x1bP777;jsgotty-kitty-v1;normal;1;0\x1b\\',
+  '\x1b]777;jsgotty-kitty-v1;normal;1;0\x18',
+ ]){feed(t,payload);assert.deepEqual(t.snapshot(),before);}
+ feed(t,'\x1b]777;jsgotty-kitty-v1;normal;1;0\x1b\\');
+ assert.deepEqual(t.kitty.normal,{flags:1,stack:[0]});
+});

package/initramfs/buninu/apps/jsgotty/tests/touch-drag-browser.test.js

@@ -0,0 +1,106 @@
+// Opt-in real bundled-xterm integration; no browser/dependency downloads.
+// CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/touch-drag-browser.test.js
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const path=require('node:path');
+const http=require('node:http');
+const {spawn}=require('node:child_process');
+const {once}=require('node:events');
+const WebSocket=require('ws');
+const root=path.join(__dirname,'../static');
+test('touch double-tap drag and image-menu right click use bundled xterm', {skip:!process.env.CHROMIUM_HEADLESS,timeout:60000},async()=>{
+ const bundle=fs.readFileSync(path.join(root,'js/gotty.js'),'utf8').replace('(i.nc = void 0));','(i.nc = void 0)); window.TestGoTTYXterm = i(634).GoTTYXterm;');
+ const server=http.createServer((req,res)=>{
+  if(req.url==='/index.css'){res.setHeader('Content-Type','text/css');res.end(fs.readFileSync(path.join(root,'css/index.css')));}
+  else if(req.url==='/bundle.js'){res.setHeader('Content-Type','text/javascript');res.end(bundle);}
+  else if(req.url==='/gestures.js'){
+   const source=fs.readFileSync(path.join(root,'js/kitty.js'),'utf8');
+   res.setHeader('Content-Type','text/javascript');
+   res.end(source.slice(source.indexOf('  function reportTouchMouse('),source.indexOf('  function ensureContextMenu('))+source.slice(source.indexOf('  function ensureContextMenu('),source.indexOf('  function bindImageContextMenu('))+source.slice(source.indexOf('  function bindImageContextMenu('),source.indexOf('  function bindImageContextMenu(')+source.slice(source.indexOf('  function bindImageContextMenu(')).indexOf('\n  function ',5))+'\nbindTouchScrolling();bindImageContextMenu();');
+  }
+  else if(req.url==='/keyboard.js'){res.setHeader('Content-Type','text/javascript');res.end(fs.readFileSync(path.join(root,'js/kitty-keyboard.js')));}
+  else res.end('<!doctype html><div id="terminal"><div id="fixture" style="width:800px;height:600px"></div></div><link rel="stylesheet" href="/index.css"><script src="/keyboard.js"></script><script src="/bundle.js"></script><script>window.wrapper=new TestGoTTYXterm(document.getElementById("fixture"));window.sent=[];wrapper.onInput(b=>sent.push(new TextDecoder().decode(b)));wrapper.kittyKeyboard.android=true;</script>');
+ });
+ server.listen(0,'127.0.0.1');await once(server,'listening');
+ const child=spawn(process.env.CHROMIUM_HEADLESS,['--no-sandbox','--disable-gpu','--remote-debugging-port=0','http://127.0.0.1:'+server.address().port],{detached:true,stdio:['ignore','ignore','pipe']});
+ let ws;
+ try{
+  const endpoint=await new Promise((resolve,reject)=>{let log='';const timer=setTimeout(()=>reject(Error('Browser startup timeout: '+log)),15000);child.on('error',reject);child.on('exit',code=>{clearTimeout(timer);reject(Error('Browser exited '+code+': '+log));});child.stderr.on('data',b=>{log+=b;const m=log.match(/DevTools listening on (ws:\/\/[^\s]+)/);if(m){clearTimeout(timer);resolve(m[1]);}});});
+  const u=new URL(endpoint);let tab;
+  for(let i=0;i<50;i++){tab=(await (await fetch('http://'+u.host+'/json/list')).json()).find(x=>x.type==='page');if(tab)break;await new Promise(r=>setTimeout(r,100));}
+  ws=new WebSocket(tab.webSocketDebuggerUrl);await once(ws,'open');let id=0;const pending=new Map();ws.on('message',data=>{const m=JSON.parse(data);if(pending.has(m.id)){const {resolve,reject}=pending.get(m.id);pending.delete(m.id);m.error?reject(m.error):resolve(m.result);}});
+  const call=(method,params)=>new Promise((resolve,reject)=>{pending.set(++id,{resolve,reject});ws.send(JSON.stringify({id,method,params}));});
+  for(let i=0;i<50;i++){const r=await call('Runtime.evaluate',{expression:'Boolean(window.wrapper)',returnByValue:true});if(r.result.value)break;await new Promise(r=>setTimeout(r,100));}
+  const result=await call('Runtime.evaluate',{awaitPromise:true,returnByValue:true,expression:`(async()=>{
+   const term=wrapper.term;
+   const write=s=>new Promise(r=>term.write(s,r));
+   const equal=(a,b)=>{if(JSON.stringify(a)!==JSON.stringify(b))throw Error(JSON.stringify({actual:a,expected:b}));};
+   await write('\\x1b[?1002h\\x1b[?1006h');
+   const terminal=document.getElementById('fixture');terminal.__gottyXterm=term;
+   const screen=term.element.querySelector('.xterm-screen'), rect=screen.getBoundingClientRect();
+   const state={placements:new Map()};
+   const xtermElements=()=>({screen});
+   const DEFAULT_TOUCH_SCROLL_THRESHOLD=24;
+   const removePlacementNode=node=>node.remove();
+   eval(await (await fetch('/gestures.js')).text());
+   const touch=(type,x=30,y=30,count=1)=>{
+    const point=new Touch({identifier:1,target:screen,clientX:rect.left+x,clientY:rect.top+y});
+    const touches=type==='touchend'||type==='touchcancel'?[]:count===1?[point]:[point,new Touch({identifier:2,target:screen,clientX:rect.left+x+30,clientY:rect.top+y})];
+    const event=new TouchEvent(type,{bubbles:true,cancelable:true,touches,changedTouches:[point]});
+    screen.dispatchEvent(event);return event.defaultPrevented;
+   };
+   const codes=()=>sent.map(s=>{const m=s.match(/<([0-9]+);[0-9]+;[0-9]+([Mm])/);return m?m[1]+m[2]:s;});
+   let focusCalls=0;const originalFocus=term._core.focus;term._core.focus=function(...args){focusCalls++;return originalFocus.apply(this,args);};
+   const firstTap=()=>{touch('touchstart');touch('touchend');
+    // Browser compatibility mouse sequence after an ordinary tap.
+    for(const type of ['mousedown','mouseup'])screen.dispatchEvent(new MouseEvent(type,{bubbles:true,clientX:rect.left+30,clientY:rect.top+30,button:0,buttons:type==='mousedown'?1:0}));};
+   sent.length=0;firstTap();equal(codes(),['0M','0m']);
+   const focusBeforeDrag=focusCalls;
+   if(!touch('touchstart'))throw Error('Second press must suppress compatibility click');
+   equal(codes(),['0M','0m','0M']); // still held, no premature release
+   touch('touchmove',80,70);touch('touchend',80,70);
+   equal(codes(),['0M','0m','0M','32M','0m']);
+   equal(focusCalls,focusBeforeDrag);
+   sent.length=0;firstTap();touch('touchstart');touch('touchend');
+   equal(codes(),['0M','0m','0M','0m']); // ordinary double click
+   for(const cancel of [()=>touch('touchcancel'),()=>touch('touchstart',30,30,2),()=>window.dispatchEvent(new Event('blur')),()=>state.cancelTouchGesture()]){
+    sent.length=0;firstTap();touch('touchstart');cancel();touch('touchend');equal(codes(),['0M','0m','0M','0m']);
+   }
+   sent.length=0;firstTap();touch('touchstart');
+   touch('touchmove',-200,-200);touch('touchend',-200,-200);
+   equal(codes(),['0M','0m','0M','32M','0m']); // release outside grid still reaches application
+   sent.length=0;touch('touchstart');touch('touchmove',30,90);touch('touchend',30,90);
+   if(!codes().length||codes().some(x=>!x.startsWith('64')))throw Error('Single touch must remain scrolling: '+codes());
+   sent.length=0;touch('touchstart');touch('touchmove',30,90);touch('touchend',30,90);
+   if(codes().some(x=>x==='0M'))throw Error('Scroll must not arm double tap');
+   // Use precisely the existing image context-menu path, with its original location.
+   const node=document.createElement('div');node.style.zIndex='0';node.getBoundingClientRect=()=>({left:0,top:0,right:1000,bottom:1000});state.placements.set('image',node);
+   screen.dispatchEvent(new MouseEvent('contextmenu',{bubbles:true,cancelable:true,clientX:rect.left+30,clientY:rect.top+30,button:2}));
+   if(state.contextMenu.root.hidden)throw Error('Menu missing');
+   const focusBeforeRight=focusCalls;
+   sent.length=0;state.contextMenu.rightButton.click();equal(focusCalls,focusBeforeRight);equal(codes(),['2M','2m']);
+   if(!state.contextMenu.root.hidden||!state.placements.has('image'))throw Error('Right click must hide menu and preserve image');
+   await write('\\x1b[?1002l');state.cancelTouchGesture();sent.length=0;
+   firstTap();touch('touchstart');touch('touchmove',80,70);touch('touchend');
+   if(codes().some(x=>/^[032][Mm]$/.test(x)))throw Error('No application mouse reporting outside mouse mode');
+   state.cancelTouchGesture();state.placements.clear();
+   term.focus();const textarea=term.textarea;
+   screen.dispatchEvent(new MouseEvent('contextmenu',{bubbles:true,cancelable:true,clientX:rect.left+30,clientY:rect.top+30,button:2}));
+   if(document.activeElement!==textarea)throw Error('Context menu must keep textarea focused for native paste');
+   const data=new DataTransfer();data.setData('text/plain','paste-check');sent.length=0;
+   textarea.dispatchEvent(new ClipboardEvent('paste',{bubbles:true,cancelable:true,clipboardData:data}));
+   if(!sent.join('').includes('paste-check'))throw Error('Paste stopped working');
+   equal(getComputedStyle(textarea).touchAction,'none');
+   equal(getComputedStyle(screen).touchAction,'manipulation');
+   touch('touchstart');
+   if(document.activeElement!==textarea)throw Error('Touch must not blur the input');
+   touch('touchend');
+   wrapper.close();return 'ok';
+  })()`});
+  assert.equal(result.exceptionDetails,undefined,JSON.stringify(result.exceptionDetails));assert.equal(result.result.value,'ok');
+ }finally{
+  ws?.close();if(child.pid){try{process.kill(-child.pid,'SIGTERM');}catch{}}
+  server.closeAllConnections();await new Promise(r=>server.close(r));
+ }
+});

package/initramfs/buninu/apps/jsgotty/tests/wheel-browser.test.js

@@ -0,0 +1,60 @@
+// Opt-in real bundled-xterm integration; no browser/dependency downloads.
+// CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const path=require('node:path');
+const http=require('node:http');
+const {spawn}=require('node:child_process');
+const {once}=require('node:events');
+const WebSocket=require('ws');
+const root=path.join(__dirname,'../static');
+test('shipped xterm reports horizontal, vertical and diagonal wheel events', {skip:!process.env.CHROMIUM_HEADLESS,timeout:60000},async()=>{
+ const bundle=fs.readFileSync(path.join(root,'js/gotty.js'),'utf8').replace('(i.nc = void 0));','(i.nc = void 0)); window.TestGoTTYXterm = i(634).GoTTYXterm;');
+ const server=http.createServer((req,res)=>{
+  if(req.url==='/bundle.js'){res.setHeader('Content-Type','text/javascript');res.end(bundle);}
+  else if(req.url==='/keyboard.js'){res.setHeader('Content-Type','text/javascript');res.end(fs.readFileSync(path.join(root,'js/kitty-keyboard.js')));}
+  else res.end('<!doctype html><div id="fixture" style="width:800px;height:600px"></div><script src="/keyboard.js"></script><script src="/bundle.js"></script><script>window.wrapper=new TestGoTTYXterm(document.getElementById("fixture"));window.sent=[];wrapper.onInput(b=>sent.push(new TextDecoder().decode(b)));wrapper.kittyKeyboard.android=true;</script>');
+ });
+ server.listen(0,'127.0.0.1');await once(server,'listening');
+ const child=spawn(process.env.CHROMIUM_HEADLESS,['--no-sandbox','--disable-gpu','--remote-debugging-port=0','http://127.0.0.1:'+server.address().port],{detached:true,stdio:['ignore','ignore','pipe']});
+ let ws;
+ try{
+  const endpoint=await new Promise((resolve,reject)=>{let log='';const timer=setTimeout(()=>reject(Error('Browser startup timeout: '+log)),15000);child.on('error',reject);child.on('exit',code=>{clearTimeout(timer);reject(Error('Browser exited '+code+': '+log));});child.stderr.on('data',b=>{log+=b;const m=log.match(/DevTools listening on (ws:\/\/[^\s]+)/);if(m){clearTimeout(timer);resolve(m[1]);}});});
+  const u=new URL(endpoint);let tab;
+  for(let i=0;i<50;i++){tab=(await (await fetch('http://'+u.host+'/json/list')).json()).find(x=>x.type==='page');if(tab)break;await new Promise(r=>setTimeout(r,100));}
+  ws=new WebSocket(tab.webSocketDebuggerUrl);await once(ws,'open');let id=0;const pending=new Map();ws.on('message',data=>{const m=JSON.parse(data);if(pending.has(m.id)){const {resolve,reject}=pending.get(m.id);pending.delete(m.id);m.error?reject(m.error):resolve(m.result);}});
+  const call=(method,params)=>new Promise((resolve,reject)=>{pending.set(++id,{resolve,reject});ws.send(JSON.stringify({id,method,params}));});
+  for(let i=0;i<50;i++){const r=await call('Runtime.evaluate',{expression:'Boolean(window.wrapper)',returnByValue:true});if(r.result.value)break;await new Promise(r=>setTimeout(r,100));}
+  const result=await call('Runtime.evaluate',{awaitPromise:true,returnByValue:true,expression:`(async()=>{
+   const term=wrapper.term;
+   const write=s=>new Promise(r=>term.write(s,r));
+   const equal=(a,b)=>{if(JSON.stringify(a)!==JSON.stringify(b))throw Error(JSON.stringify({actual:a,expected:b}));};
+   await write('\\x1b[?1002h\\x1b[?1006h');
+   const screen=term.element.querySelector('.xterm-screen'), rect=screen.getBoundingClientRect();
+   const wheel=(deltaX,deltaY,mods={})=>{
+    sent.length=0;
+    const event=new WheelEvent('wheel',{clientX:rect.left+20,clientY:rect.top+20,deltaX,deltaY,deltaMode:1,bubbles:true,cancelable:true,...mods});
+    screen.dispatchEvent(event);
+    if(term._core.coreMouseService.areMouseEventsActive&&!event.defaultPrevented)throw Error('Wheel default was not prevented');
+    return sent.map(s=>Number(s.match(/<([0-9]+);/)[1]));
+   };
+   equal(wheel(-1,0),[66]);equal(wheel(1,0),[67]);
+   equal(wheel(0,-1,{shiftKey:true}),[68]);equal(wheel(0,1,{shiftKey:true}),[69]);
+   equal(wheel(0,-1),[64]);equal(wheel(0,1),[65]);
+   equal(wheel(1,-1),[67,64]);
+   equal(wheel(-1,0,{shiftKey:true,altKey:true,ctrlKey:true}),[94]);
+   for(let bits=0;bits<8;bits++) {
+    const mods={shiftKey:!!(bits&1),altKey:!!(bits&2),ctrlKey:!!(bits&4)};
+    for(const [dx,dy,code] of [[0,-1,64],[0,1,65],[-1,0,66],[1,0,67]])
+     equal(wheel(dx,dy,mods),[code+(bits<<2)]);
+   }
+   await write('\\x1b[?1002l');equal(wheel(1,0),[]);
+   wrapper.close();return 'ok';
+  })()`});
+  assert.equal(result.exceptionDetails,undefined,JSON.stringify(result.exceptionDetails));assert.equal(result.result.value,'ok');
+ }finally{
+  ws?.close();if(child.pid){try{process.kill(-child.pid,'SIGTERM');}catch{}}
+  server.closeAllConnections();await new Promise(r=>server.close(r));
+ }
+});

package/initramfs/buninu/apps/jsmdcui/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 All notable user-visible changes to jsmdcui are documented here.
 
+## [0.19.4] - 2026-10-26
+
+### Fixed
+
+- Catch failures during Go regexp conversion as well as compilation, and
+  bound the converter's nested-group recursion. An excessively nested rule
+  is disabled individually instead of throwing from `SyntaxDefinition` or
+  causing the loader to silently discard the entire syntax definition.
+  Other rules remain usable; this does not limit input line length.
+
+## [0.19.3] - 2026-10-26
+
+### Fixed
+
+- Restore Dockerfile highlighting and improve compatibility with Micro's
+  syntax definitions by translating Go regular-expression flags and POSIX
+  character classes into JavaScript equivalents. Scoped flags retain their
+  scope rather than changing the entire expression.
+- Fix nested highlighting regions, especially HTML and XML attributes:
+  closing a quoted attribute now returns to the surrounding tag, and closing
+  the tag returns to normal text. Unfinished attributes still carry their
+  highlighting state across lines.
+- Replace recursive region scanning with an iterative scanner so long,
+  minified lines can be highlighted through their final token without stack
+  exhaustion or truncation.
+- Prevent zero-width region cycles and cyclic syntax/state trees from looping
+  indefinitely. Zero-width matches advance safely over Unicode characters,
+  and NUL characters or isolated surrogate units do not leak region state.
+  These guards do not impose a timeout on an individual JavaScript RegExp.
+
+### Added
+
+- Add syntax samples and a reproducible comparison against Micro's Go
+  highlighter, including JavaScript, Python and Markdown with upstream syntax
+  definitions. See [the comparison guide](tests/syntax-parity/README.md) for
+  generating the HTML comparison locally; generated HTML is not bundled.
+
+### Changed
+
+- Markdown heading tests detect Bun's actual raw-HTML parsing behavior instead
+  of relying on version checks, accommodating the slash-tag behavior change
+  while preserving fail-closed coverage. The heading suites were verified on
+  Bun 1.4.0 through 1.4.4.
+
 ## [0.19.2] - 2026-09-21
 
 ### Added

package/initramfs/buninu/apps/jsmdcui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsmdcui",
-  "version": "0.19.2",
+  "version": "0.19.4",
   "description": "Markdown as a Common UI for Terminals and Web Browsers",
   "type": "module",
   "main": "./src/index.js",

package/initramfs/buninu/apps/jsmdcui/src/highlight/go-regexp.js

@@ -0,0 +1,83 @@
+// Adapt Go regexp syntax without changing the upstream syntax definitions.
+// Scoped JS modifiers preserve flag changes across alternatives, but not out
+// of their enclosing group. They add no capturing groups. Modifiers are only
+// emitted where flags differ from those in effect, so flag-free patterns
+// do not depend on engine support for them.
+export function convertGoRegexp(pattern) {
+  const source = String(pattern);
+  if (!/\(\?[ims-]|\[\^?\]|\(\?P<|\[:[a-z]+:\]/.test(source)) return source;
+  let i = 0;
+  function expression(inherited, active, nested = false, depth = 0) {
+    // Bound syntax-rule recursion, not the length of text being highlighted.
+    if (depth > 256) throw new RangeError('Go regexp nesting exceeds 256 groups');
+    const flags = new Set(inherited);
+    let output = '', wrapped = false;
+    function open() {
+      const on = 'ims'.split('').filter(f => flags.has(f) && !active.has(f)).join('');
+      const off = 'ims'.split('').filter(f => !flags.has(f) && active.has(f)).join('');
+      if (!on && !off) return;
+      output += `(?${on}${off ? '-' + off : ''}:`;
+      wrapped = true;
+    }
+    function close() { if (wrapped) output += ')'; wrapped = false; }
+    while (i < source.length) {
+      const ch = source[i];
+      if (ch === ')' && nested) { i++; close(); return output; }
+      if (ch === '|') { close(); output += '|'; i++; continue; }
+      const directive = ch === '(' && source.slice(i).match(/^\(\?([ims]*)(?:-([ims]+))?\)/);
+      if (directive && (directive[1] || directive[2])) {
+        close();
+        for (const f of directive[1]) flags.add(f);
+        for (const f of directive[2] || '') flags.delete(f);
+        i += directive[0].length;
+        continue;
+      }
+      if (!wrapped) open();
+      if (ch === '\\') { output += source.slice(i, i + 2); i += 2; continue; }
+      if (ch === '[') {
+        output += source[i++];
+        if (source[i] === '^') output += source[i++];
+        // Go permits a literal ] as the first member of a character class.
+        if (source[i] === ']') { output += '\\]'; i++; }
+        while (i < source.length) {
+          const posix = source.slice(i).match(/^\[:([a-z]+):\]/);
+          if (posix && POSIX_CLASSES[posix[1]] !== undefined) {
+            output += POSIX_CLASSES[posix[1]]; i += posix[0].length; continue;
+          }
+          const c = source[i++]; output += c;
+          if (c === '\\' && i < source.length) output += source[i++];
+          else if (c === ']') break;
+        }
+        continue;
+      }
+      if (ch === '(') {
+        const scoped = source.slice(i).match(/^\(\?([ims]*)(?:-([ims]+))?:/);
+        const childFlags = new Set(flags);
+        if (scoped) {
+          for (const f of scoped[1]) childFlags.add(f);
+          for (const f of scoped[2] || '') childFlags.delete(f);
+          output += '(?:'; i += scoped[0].length;
+        } else {
+          const prefix = source.slice(i).match(/^\(\?(?:[:=!]|<[=!]|<[^>]+>|P<[^>]+>)/);
+          output += prefix ? prefix[0].replace('(?P<', '(?<') : '(';
+          i += prefix ? prefix[0].length : 1;
+        }
+        output += expression(childFlags, flags, true, depth + 1) + ')';
+        continue;
+      }
+      output += ch; i++;
+    }
+    close();
+    return output;
+  }
+  return expression(new Set(), new Set());
+}
+
+// Class contents, not nested [...] expressions: e.g. [[:alnum:]._-].
+const POSIX_CLASSES = {
+  alnum: 'A-Za-z0-9', alpha: 'A-Za-z', ascii: '\\x00-\\x7F',
+  blank: ' \\t', cntrl: '\\x00-\\x1F\\x7F', digit: '0-9',
+  graph: '!-~', lower: 'a-z', print: ' -~',
+  punct: '!-/:-@\\[-`{-~', space: '\\t\\n\\v\\f\\r ',
+  upper: 'A-Z', word: 'A-Za-z0-9_', xdigit: 'A-Fa-f0-9',
+};