buninu-browser 0.7.0 → 0.9.1

package/test/web-audio.test.js

@@ -0,0 +1,264 @@
+import {test,expect} from 'bun:test';
+import {createWebAudioScope} from '../lib/audio/web-audio.js';
+
+function setup(realtime = false) {
+  const outputs=[],closed=[],errors=[];
+  const scope=createWebAudioScope({realtime,
+    audio:{
+      open(options,listener){outputs.push({options,listener,pcm:[]});return outputs.length;},
+      write(id,bytes){outputs[id-1].pcm.push(new Int16Array(bytes.buffer,bytes.byteOffset,bytes.byteLength/2).slice());},
+      close(id){closed.push(id);},
+    },reportError:error=>errors.push(String(error)),
+  });
+  const context=new scope.api.AudioContext({sampleRate:8000});
+  const pull=(frames=128)=>{
+    const output=outputs.at(-1);
+    output.listener({event:'request',bytes:frames*4});
+    return output.pcm.at(-1);
+  };
+  return {...scope,context,outputs,closed,errors,pull};
+}
+
+test('oscillator PCM follows frequency, gain, disconnect and reconnect without duplicate connections',()=>{
+  const f=setup(),c=f.context,o=c.createOscillator(),g=c.createGain();
+  try {
+    o.frequency.setValueAtTime(500,c.currentTime);g.gain.value=.25;
+    expect(o.connect(g)).toBe(g);g.connect(c.destination);g.connect(c.destination);o.start();
+    const first=f.pull();
+    expect(first[8]).toBeCloseTo(8192,0); // Stereo frame 4: sin(pi/2) * .25.
+    for(let i=0;i<first.length;i+=2)expect(first[i]).toBe(first[i+1]);
+    o.frequency.setValueAtTime(1000,c.currentTime);
+    const second=f.pull();expect(second[4]).toBeCloseTo(8192,0);
+    o.disconnect();expect([...f.pull()].every(x=>x===0)).toBe(true);
+    o.connect(g);g.gain.value=.1;expect(f.pull()[4]).toBeCloseTo(3277,0);
+    expect(c.currentTime).toBe(512/8000);
+    expect(f.outputs).toHaveLength(1);
+  }finally{f.dispose();}
+  expect(f.closed).toEqual([1]);expect(f.errors).toEqual([]);
+});
+
+test('scheduled start, stop, gain ramps and ended events use the audio sample timeline',async()=>{
+  const f=setup(),c=f.context,o=c.createOscillator(),g=c.createGain();let ended=0;
+  try {
+    o.frequency.value=500;o.connect(g).connect(c.destination);
+    g.gain.setValueAtTime(0,0).linearRampToValueAtTime(1,.032);
+    o.onended=()=>ended++;o.start(.016);o.stop(.04);
+    const samples=f.pull(512);
+    expect([...samples.slice(0,128*2)].every(x=>x===0)).toBe(true);
+    expect(samples[(128+4)*2]).toBeCloseTo(Math.round(32767*132/256),0);
+    expect([...samples.slice(320*2)].every(x=>x===0)).toBe(true);
+    await Bun.sleep(10);expect(ended).toBe(1);
+    f.pull();await Bun.sleep(5);expect(ended).toBe(1);
+    expect(()=>o.start()).toThrow();
+  }finally{f.dispose();}
+});
+
+test('suspend freezes the context and resume reopens only its own stream; close rejects later resume',async()=>{
+  const f=setup(),c=f.context,o=c.createOscillator();
+  o.connect(c.destination);o.start();f.pull();const time=c.currentTime;
+  await c.suspend();expect(c.state).toBe('suspended');expect(f.closed).toEqual([1]);
+  f.outputs[0].listener({event:'request',bytes:512});expect(c.currentTime).toBe(time);
+  await c.resume();expect(c.state).toBe('running');expect(f.outputs).toHaveLength(2);
+  f.pull();expect(c.currentTime).toBeGreaterThan(time);
+  await c.close();expect(c.state).toBe('closed');expect(f.closed).toEqual([1,2]);
+  await expect(c.resume()).rejects.toMatchObject({name:'InvalidStateError'});
+  f.dispose();expect(f.closed).toEqual([1,2]);
+});
+
+test('parameter ramps can be held and cancelled; invalid times, ports and cross-context graphs reject',()=>{
+  const f=setup(),c=f.context,o=c.createOscillator(),g=c.createGain();
+  try {
+    const p=g.gain;
+    p.setValueAtTime(0,0).linearRampToValueAtTime(1,.1).cancelAndHoldAtTime(.05);
+    f.pull(800);expect(p.value).toBeCloseTo(.5);
+    p.cancelScheduledValues(0);p.value=.25;expect(p.value).toBe(.25);
+    expect(()=>p.setValueAtTime(1,-1)).toThrow(RangeError);
+    expect(()=>p.setValueAtTime(NaN,0)).toThrow(TypeError);
+    expect(()=>p.exponentialRampToValueAtTime(0,1)).toThrow(RangeError);
+    expect(()=>o.stop()).toThrow();
+    expect(()=>o.connect(c.destination,1)).toThrow();
+    const other=new f.api.AudioContext();expect(()=>o.connect(other.destination)).toThrow();
+  }finally{f.dispose();}
+});
+
+test('multiple sources mix in one stream and cycles cannot recurse indefinitely',()=>{
+  const f=setup(),c=f.context,a=c.createOscillator(),b=new f.api.OscillatorNode(c,{frequency:1000,detune:1200});
+  try {
+    const g=new f.api.GainNode(c,{gain:.1});
+    a.frequency.value=500;a.connect(g);b.connect(g);g.connect(c.destination);
+    a.start();b.start();const samples=f.pull();
+    expect(samples[4]).toBeCloseTo(Math.round(32767*.1*Math.sin(Math.PI/4)),0);
+    expect(f.outputs).toHaveLength(1);
+    g.connect(g);expect([...f.pull()].every(Number.isFinite)).toBe(true);
+    expect(()=>new f.api.AudioNode(c)).toThrow(TypeError);
+    expect(()=>new f.api.AudioParam()).toThrow(TypeError);
+    expect(f.api.webkitAudioContext).toBe(f.api.AudioContext);
+  }finally{f.dispose();}
+});
+
+test('sample buffers play through the existing PCM graph with looping, rate and ended events',async()=>{
+ const f=setup(),c=f.context;
+ try{
+  const b=c.createBuffer(1,4,8000);b.copyToChannel(new Float32Array([0,.25,.5,.75]),0);
+  expect([...b.getChannelData(0)]).toEqual([0,.25,.5,.75]);expect(b.duration).toBe(.0005);
+  const copy=new Float32Array(3);b.copyFromChannel(copy,0,1);expect([...copy]).toEqual([.25,.5,.75]);
+  expect(()=>b.getChannelData(1)).toThrow();
+  const node=c.createBufferSource();let ended=0;node.buffer=b;node.onended=()=>ended++;
+  node.loop=true;node.loopStart=1/8000;node.loopEnd=3/8000;
+  node.connect(c.destination);node.start();
+  const pcm=f.pull(8);expect([...pcm.filter((_,i)=>i%2===0)]).toEqual([0,8192,16384,8192,16384,8192,16384,8192]);
+  node.stop(c.currentTime);f.pull(128);await Bun.sleep(10);expect(ended).toBe(1);
+  const faster=c.createBufferSource();faster.buffer=b;faster.playbackRate.value=2;faster.connect(c.destination);faster.start();
+  expect([...f.pull(128).filter((_,i)=>i%2===0)].filter(x=>x!==0)).toEqual([16384]);
+  expect(()=>faster.start()).toThrow();
+ }finally{f.dispose();}
+});
+
+test('decodeAudioData detaches input, resamples samples, completes callbacks and closes the decoder',async()=>{
+ let closed=0,success=0,failures=0;
+ const scope=createWebAudioScope({realtime:false,decodeAudio:async bytes=>{
+  if(bytes[0]===0)throw Error('invalid compressed sound');
+  let first=true;return {sampleRate:16000,channels:1,nextSamples(){if(!first)return null;first=false;return new Float32Array([0,.25,.5,.75,1,.75,.5,.25]);},close(){closed++;}};
+ }});
+ const c=new scope.api.AudioContext({sampleRate:8000});
+ try{
+  const input=new Uint8Array([1]).buffer;
+  const pending=c.decodeAudioData(input,b=>{success++;expect(b.sampleRate).toBe(8000);});
+  expect(input.byteLength).toBe(0);
+  const b=await pending;expect([...b.getChannelData(0)]).toEqual([0,.5,1,.5]);expect(success).toBe(1);expect(closed).toBe(1);
+  await expect(c.decodeAudioData(new Uint8Array([0]).buffer,null,e=>{failures++;expect(e.name).toBe('EncodingError');})).rejects.toMatchObject({name:'EncodingError'});
+  expect(failures).toBe(1);
+  await expect(c.decodeAudioData(new Uint8Array([1]))).rejects.toThrow('ArrayBuffer');
+ }finally{scope.dispose();}
+});
+
+test('BiquadFilterNode reports frequency response and filters actual PCM',async()=>{
+ const t=setup(),{context}=t;
+ try{
+  const filter=context.createBiquadFilter();filter.frequency.value=200;filter.Q.value=0;
+  expect(filter).toBeInstanceOf(t.api.BiquadFilterNode);
+  const frequencies=new Float32Array([0,100,2000,5000]),magnitude=new Float32Array(4),phase=new Float32Array(4);
+  filter.getFrequencyResponse(frequencies,magnitude,phase);
+  expect(magnitude[0]).toBeCloseTo(1,5);expect(magnitude[1]).toBeGreaterThan(.8);
+  expect(magnitude[2]).toBeLessThan(.01);expect(Number.isNaN(magnitude[3])).toBe(true);
+  expect(()=>filter.getFrequencyResponse(frequencies,new Float32Array(1),phase)).toThrow();
+  const oscillator=context.createOscillator();oscillator.frequency.value=2000;oscillator.connect(filter);filter.connect(context.destination);oscillator.start();
+  await context.resume();let filtered;
+  for(let i=0;i<12;i++)filtered=t.pull();
+  const rms=samples=>Math.sqrt(samples.reduce((sum,value)=>sum+value*value,0)/samples.length);
+  expect(rms(filtered)).toBeLessThan(300);
+  filter.type='highpass';let passed;
+  for(let i=0;i<12;i++)passed=t.pull();
+  expect(rms(passed)).toBeGreaterThan(10000);
+ }finally{await context.close();t.dispose();}
+});
+
+
+test('live synthesis yields between bounded packets so page timers can schedule future notes', async()=>{
+ const f=setup(true),c=f.context;let timer;
+ try {
+  let next=0;
+  const schedule=()=>{while(next<c.currentTime+.1){const o=c.createOscillator();o.frequency.value=500;o.connect(c.destination);o.start(next);o.stop(next+.055);next+=.04;}};
+  schedule();timer=setInterval(schedule,25);
+  const started=performance.now();f.outputs[0].listener({event:'request',bytes:8000*.25*4});
+  expect(c.currentTime).toBeLessThanOrEqual(.08+128/c.sampleRate);
+  await Bun.sleep(170);
+  expect(c.currentTime).toBeLessThan((performance.now()-started)/1000+.10);
+  const pcm=f.outputs[0].pcm;expect(pcm.length).toBeGreaterThan(3);
+  expect(pcm.every(packet=>packet.length<=8000*.096*2)).toBe(true);
+  expect(pcm.every(packet=>packet.some(value=>value!==0))).toBe(true);
+ } finally {clearInterval(timer);f.dispose();}
+});
+
+
+test('silent connected gain branches remain reconnectable and preserve elapsed automation',()=>{
+ const f=setup(),c=f.context;
+ try {
+  const master=c.createGain();master.connect(c.destination);
+  for(let i=0;i<300;i++){const g=c.createGain();g.gain.setValueAtTime(.1,0).exponentialRampToValueAtTime(.001,.1);g.connect(master);}
+  const gain=c.createGain();gain.gain.setValueAtTime(0,0).linearRampToValueAtTime(.5,.032);gain.connect(master);
+  expect([...f.pull(256)].every(v=>v===0)).toBe(true);
+  const o=c.createOscillator();o.frequency.value=500;o.connect(gain);o.start();
+  expect(f.pull()[8]).toBeCloseTo(Math.round(32767*.5),0);
+  o.disconnect();expect([...f.pull()].every(v=>v===0)).toBe(true);
+  o.connect(gain);expect(f.pull().some(v=>v!==0)).toBe(true);
+ }finally{f.dispose();}
+});
+
+
+test('live audio catches up after repeated long paint tasks instead of slowing its clock',async()=>{
+ const f=setup(true),c=f.context,o=c.createOscillator();let painting;
+ try {
+  o.connect(c.destination);o.start();
+  f.outputs[0].listener({event:'request',bytes:8000*2*4});
+  const started=performance.now();
+  painting=setInterval(()=>{const end=performance.now()+140;while(performance.now()<end){}},16);
+  await Bun.sleep(700);
+  clearInterval(painting);
+  const elapsed=(performance.now()-started)/1000;
+  expect(c.currentTime).toBeGreaterThan(elapsed*.9);
+  expect(c.currentTime).toBeLessThan(elapsed+.10);
+ }finally{clearInterval(painting);f.dispose();}
+});
+
+test('unreferenced finished filter graphs are collected after their real tails decay',async()=>{
+ const f=setup(),c=f.context;
+ let weakFilter,weakGain;
+ (()=>{
+  const source=c.createBufferSource(),filter=c.createBiquadFilter(),gain=c.createGain();
+  weakFilter=new WeakRef(filter);weakGain=new WeakRef(gain);
+  filter.type='lowpass';filter.frequency.value=100;filter.Q.value=10;
+  const buffer=c.createBuffer(1,1,c.sampleRate);buffer.getChannelData(0)[0]=1;source.buffer=buffer;
+  source.connect(filter).connect(gain).connect(c.destination);source.start();
+ })();
+ try{
+  f.pull(128);await Bun.sleep(5);Bun.gc(true);await Bun.sleep(0);
+  expect(weakFilter.deref()!==undefined).toBe(true); // tail owns its path after source ends
+  expect(f.pull(128).some(v=>v!==0)).toBe(true);
+  f.pull(8000); // let the IIR decay below float32's normal range
+  for(let i=0;i<4;i++){await Bun.sleep(5);expect(f.pull().every(v=>v===0)).toBe(true);Bun.gc(true);}
+  expect(weakFilter.deref()===undefined).toBe(true);
+  expect(weakGain.deref()===undefined).toBe(true);
+  expect(f.pull().every(v=>v===0)).toBe(true);
+ }finally{f.dispose();}
+});
+
+test('an author-held silent filter remains reconnectable after collection of other graphs',async()=>{
+ const f=setup(),c=f.context,filter=c.createBiquadFilter();
+ filter.type='lowpass';filter.frequency.value=500;filter.connect(c.destination);
+ try{
+  f.pull(256);await Bun.sleep(5);Bun.gc(true);
+  const source=c.createOscillator();source.frequency.value=200;source.connect(filter);source.start();
+  expect(f.pull(256).some(v=>v!==0)).toBe(true);
+  source.stop();f.pull(8000);expect(f.pull().every(v=>v===0)).toBe(true);
+  const next=c.createOscillator();next.frequency.value=200;next.connect(filter);next.start();
+  expect(f.pull(256).some(v=>v!==0)).toBe(true);
+ }finally{f.dispose();}
+});
+
+test('future scheduled voices retain intermediate processing nodes until playback',async()=>{
+ const f=setup(),c=f.context;let weak;
+ (()=>{const source=c.createOscillator(),filter=c.createBiquadFilter(),gain=c.createGain();
+  source.frequency.value=500;filter.frequency.value=1000;gain.gain.value=.25;
+  weak=new WeakRef(filter);source.connect(filter).connect(gain).connect(c.destination);source.start(.1);source.stop(.2);
+ })();
+ try{
+  for(let i=0;i<3;i++){await Bun.sleep(5);Bun.gc(true)}
+  expect(weak.deref()!==undefined).toBe(true);
+  const samples=f.pull(2048);
+  expect(samples.slice(0,800*2).every(v=>v===0)).toBe(true);
+  expect(samples.slice(800*2).some(v=>v!==0)).toBe(true);
+ }finally{f.dispose();}
+});
+
+test('AudioParam modulation keeps its running input alive through weak input connections',async()=>{
+ const f=setup(),c=f.context,signal=c.createOscillator(),gain=c.createGain();
+ gain.gain.value=0;signal.frequency.value=500;signal.connect(gain).connect(c.destination);signal.start();
+ let mod;
+ (()=>{const oscillator=c.createOscillator();oscillator.type='square';oscillator.frequency.value=0;oscillator.connect(gain.gain);oscillator.start();mod=new WeakRef(oscillator)})();
+ try{
+  await Bun.sleep(5);Bun.gc(true);
+  expect(f.pull()[8]).toBeCloseTo(32767,0);
+  mod.deref().stop();expect(f.pull().every(v=>v===0)).toBe(true);
+ }finally{f.dispose();}
+});

package/test/webgl-clip.test.js

@@ -0,0 +1,9 @@
+import{test,expect}from'bun:test';
+import{clipTriangles}from'../lib/renderer/webgl/clip.js';
+test('homogeneous clipping keeps indexed geometry inside and interpolates crossings',()=>{
+ const source=new Float32Array([-.5,-.5,0,1,0,.5,-.5,0,1,1,0,.5,0,1,.5]),indices=[0,1,2];
+ const inside=clipTriangles(source,indices,5);expect(inside.vertices).toBe(source);expect(inside.indices).toBe(indices);
+ source[5]=2;const clipped=clipTriangles(source,indices,5);expect(clipped.indices.length).toBe(6);
+ for(let i=0;i<clipped.vertices.length;i+=5){const v=clipped.vertices.subarray(i,i+5);expect(Math.abs(v[0])).toBeLessThanOrEqual(v[3]);expect(v[4]).toBeGreaterThanOrEqual(0);expect(v[4]).toBeLessThanOrEqual(1);}
+ source[0]=NaN;expect(clipTriangles(source,indices,5).indices).toEqual([]);
+});

package/test/webgl-cpu-fragment.test.js

@@ -0,0 +1,43 @@
+import {beforeAll,expect,test} from 'bun:test';
+import init from '../usr/lib/canvaskit/canvaskit.js';
+import {compileStage,shader,floatImage,imageShader} from '../lib/renderer/webgl/pipeline.js';
+import {runCPUFragment} from '../lib/renderer/webgl/cpu-fragment.js';
+let kit;
+beforeAll(async()=>{kit=await init({wasmBinary:await Bun.file(new URL('../usr/lib/canvaskit/canvaskit.wasm',import.meta.url)).arrayBuffer()});});
+function compare(source,values=new Map()){
+ const stage=compileStage(kit,source,'fragment');expect(stage.cpu).not.toBeNull();
+ const width=8,height=8,coverage=new Float32Array(width*height*4),varyings=stage.varyings.map(()=>new Float32Array(coverage.length));
+ for(let y=0;y<height;y++)for(let x=0;x<width;x++){const i=(y*width+x)*4;coverage.set([1,height-y-.5,.5,1],i);for(const v of varyings)v.set([(x+.5)/width,(y+.5)/height,.25,1],i);}
+ const images=[coverage,...varyings].map(v=>floatImage(kit,width,height,v)),children=images.map(i=>imageShader(kit,i)),surface=kit.MakeSurface(width,height),paint=new kit.Paint();let effect;
+ try{effect=shader(kit,stage,values,children);paint.setShader(effect);surface.getCanvas().drawPaint(paint);surface.flush();const snapshot=surface.makeImageSnapshot();let expected;try{expected=snapshot.readPixels(0,0,{width,height,colorType:kit.ColorType.RGBA_8888,alphaType:kit.AlphaType.Premul,colorSpace:kit.ColorSpace.SRGB});}finally{snapshot.delete();}
+  const actual=runCPUFragment(stage,values,[],coverage,varyings,width,height,0,0,height);
+  let difference=0;for(let i=0;i<actual.length;i++)difference=Math.max(difference,Math.abs(actual[i]-expected[i]));expect(difference).toBeLessThanOrEqual(2);return actual;
+ }finally{paint.delete();effect?.delete();surface.delete();for(const c of children)c.delete();for(const i of images)i.delete();stage.effect.delete();}
+}
+test('numeric CPU fragment lighting and derivatives agree with CanvasKit',()=>{
+ compare('precision highp float;varying vec3 n;uniform vec3 light;void main(){vec3 N=normalize(n);float v=pow(max(dot(N,normalize(light)),0.),3.);gl_FragColor=vec4(v,abs(dFdx(n.x)),abs(dFdy(n.y)),.75);}',new Map([['light',[1,2,3]]]));
+});
+test('conditional expressions and logical operators do not evaluate skipped side effects',()=>{
+ const pixels=compare('precision highp float;float bump(inout float x){x+=.2;return x;}void main(){float x=0.;float a=true?bump(x):bump(x);bool b=false&&(bump(x)>0.);bool c=true||(bump(x)>0.);gl_FragColor=vec4(x,a,0.,1.);}');
+ expect([...pixels.slice(0,4)]).toEqual([51,51,0,255]);
+});
+test('mutable shader globals are reset between pixels',()=>{
+ const pixels=compare('precision highp float;float v=.25;void main(){v+=.25;gl_FragColor=vec4(v,0.,0.,1.);}');
+ expect(pixels[0]).toBe(128);expect(pixels.at(-4)).toBe(128);
+});
+test('control-flow derivatives retain the CanvasKit fallback',()=>{
+ for(const body of ['if(gl_FragCoord.x>3.)gl_FragColor=vec4(dFdx(gl_FragCoord.x));else gl_FragColor=vec4(1.);']){
+  const stage=compileStage(kit,'precision highp float;void main(){'+body+'}','fragment');expect(stage.cpu).toBeNull();stage.effect.delete();
+ }
+});
+test('numeric vertex transforms and varyings agree with CanvasKit float output',async()=>{
+ const {runVertices}=await import('../lib/renderer/webgl/pipeline.js');
+ const stage=compileStage(kit,'attribute vec3 position;attribute vec3 normal;uniform mat4 model;uniform mat3 normals;varying vec3 v;void main(){v=normalize(normals*normal);gl_Position=model*vec4(position,1.);}','vertex');
+ try{
+  expect(stage.cpuVertex).not.toBeNull();
+  const values=new Map([['model',[2,0,0,.1,0,3,0,.2,0,0,4,.3,5,6,7,1]],['normals',[1,0,0,0,2,0,0,0,3]]]);
+  const attrs=new Map([['position',new Float32Array([1,2,3,-1,.5,2])],['normal',new Float32Array([1,2,3,3,2,1])]]);
+  const actual=runVertices(kit,stage,values,attrs,2),reference=runVertices(kit,{...stage,cpuVertex:null},values,attrs,2);
+  for(let i=0;i<actual.length;i++)expect(actual[i]).toBeCloseTo(reference[i],5);
+ }finally{stage.effect.delete();}
+});

package/test/window-named-properties.test.js

@@ -0,0 +1,41 @@
+import {test, expect} from 'bun:test';
+import {RendererHost} from '../lib/renderer/host.js';
+import {parseHTMLDocument} from '../lib/happy-dom/parser.js';
+
+test('Window named elements are live, shadowable, and available in classic scripts and inline handlers', async () => {
+  const host = new RendererHost();
+  try {
+    await host.call('loadDocument', {url:'https://example.test/',source:`
+      <textarea id="source">hello</textarea><textarea id="result"></textarea>
+      <form name="namedForm"></form><input name="notGlobal"><div id="dupe"></div><div id="dupe"></div>
+      <button onclick="result.value=source.value.toUpperCase()">Convert</button>
+      <script>window.initial = source.value; window.group = dupe;</script>`,contentType:'text/html'});
+    expect(await host.call('evaluate', '[initial, namedForm.tagName, typeof notGlobal, dupe.length, dupe.item(0).tagName]')).toEqual(['hello','FORM','undefined',2,'DIV']);
+    expect(await host.call('evaluate', 'document.querySelector("button").click(); result.value')).toBe('HELLO');
+    expect(await host.call('evaluate', 'source.id="renamed"; [typeof source, renamed.value]')).toEqual(['undefined','hello']);
+    expect(await host.call('evaluate', 'window.renamed=42; let x=renamed;delete window.renamed;[x,renamed.value]')).toEqual([42,'hello']);
+    expect(await host.call('evaluate', 'document.querySelectorAll("#dupe")[0].remove(); [group.length, dupe.tagName]')).toEqual([1,'DIV']);
+    expect(await host.call('evaluate', 'renamed.remove(); typeof renamed')).toBe('undefined');
+    expect(await host.call('evaluate', `eval('(async()=>{\\nresult.value="first"\\nresult.value += " second"\\n})()'); result.value`)).toBe('first second');
+  } finally {host.close();}
+},20000);
+
+test('type selectors accept underscores, including escaped punctuation and selector lists', () => {
+  const {document} = parseHTMLDocument('<x_widget></x_widget><g:family_creation></g:family_creation>');
+  expect(document.querySelectorAll('x_widget, g\\:family_creation').length).toBe(2);
+});
+
+test('deferred absolute backgrounds paint before later relative links, including after relayout', async () => {
+  const host = new RendererHost();
+  try {
+    await host.call('loadDocument',{url:'https://example.test/',contentType:'text/html',source:`
+      <style>body{margin:0}.container{position:relative}.background{position:absolute;inset:0;background:red}
+      .front{position:relative}a{display:block;height:50px;background:green}</style>
+      <div class="container"><div class="background"><div style="height:100%"></div></div><div class="front"><a href="#ok">Click</a></div></div>`});
+    for (const width of [800,600,800]) {
+      await host.call('resize',width,600,1);
+      expect(await host.call('evaluate','document.elementFromPoint(20,20).tagName')).toBe('A');
+      expect(await host.call('click',20,20)).toBeTruthy();
+    }
+  }finally{host.close();}
+},20000);

package/vendor/happy-dom/packages/happy-dom/src/config/HTMLElementConfig.ts

@@ -78,7 +78,7 @@ export default <
 	},
 	textarea: {
 		className: 'HTMLTextAreaElement',
-		contentModel: HTMLElementConfigContentModelEnum.anyDescendants
+		contentModel: HTMLElementConfigContentModelEnum.rcdata
 	},
 	script: {
 		className: 'HTMLScriptElement',
@@ -499,7 +499,7 @@ export default <
 	},
 	title: {
 		className: 'HTMLTitleElement',
-		contentModel: HTMLElementConfigContentModelEnum.anyDescendants
+		contentModel: HTMLElementConfigContentModelEnum.rcdata
 	},
 	tr: {
 		className: 'HTMLTableRowElement',

package/vendor/happy-dom/packages/happy-dom/src/config/HTMLElementConfigContentModelEnum.ts

@@ -1,5 +1,6 @@
 enum HTMLElementConfigContentModelEnum {
 	rawText = 'rawText',
+	rcdata = 'rcdata',
 	noSelfDescendants = 'noSelfDescendants',
 	noFirstLevelSelfDescendants = 'noFirstLevelSelfDescendants',
 	noForbiddenFirstLevelDescendants = 'noForbiddenFirstLevelDescendants',

package/vendor/happy-dom/packages/happy-dom/src/html-parser/HTMLParser.ts

@@ -326,6 +326,18 @@ export default class HTMLParser {
 					break;
 			}
 
+			if (this.currentNode && this.readState === MarkupReadStateEnum.any &&
+				(<Element>this.currentNode)[PropertySymbol.namespaceURI] === NamespaceURI.html &&
+				HTMLElementConfig[(<Element>this.currentNode)[PropertySymbol.localName]]?.contentModel === HTMLElementConfigContentModelEnum.rcdata) {
+				const tag = (<Element>this.currentNode)[PropertySymbol.localName];
+				const end = new RegExp('</' + tag + '(?=[\\t\\n\\f\\r />])[^>]*>', 'gi');
+				end.lastIndex = this.markupRegExp.lastIndex;
+				const closing = end.exec(html);
+				const text = html.slice(this.markupRegExp.lastIndex, closing?.index ?? html.length);
+				this.parseRawTextElementContent(tag, text);
+				this.markupRegExp.lastIndex = closing ? end.lastIndex : html.length;
+			}
+
 			lastIndex = this.markupRegExp.lastIndex;
 		}
 
@@ -467,12 +479,14 @@ export default class HTMLParser {
 
 		const tagName = this.nextElement![PropertySymbol.tagName]!;
 		const lowerTagName = tagName.toLowerCase();
-		const config = HTMLElementConfig[lowerTagName];
+		const config = this.nextElement![PropertySymbol.namespaceURI] === NamespaceURI.html
+			? HTMLElementConfig[lowerTagName] : undefined;
 		let previousCurrentNode: Node | null = null;
 
 		while (previousCurrentNode !== this.rootNode) {
 			const parentLowerTagName = (<Element>this.currentNode)[PropertySymbol.tagName]?.toLowerCase();
-			const parentConfig = parentLowerTagName ? HTMLElementConfig[parentLowerTagName] : null;
+			const parentConfig = parentLowerTagName && (<Element>this.currentNode)[PropertySymbol.namespaceURI] === NamespaceURI.html
+				? HTMLElementConfig[parentLowerTagName] : null;
 
 			if (previousCurrentNode === this.currentNode) {
 				throw new Error(
@@ -601,7 +615,8 @@ export default class HTMLParser {
 			// Raw text elements (e.g. <script>) should be appended after the raw text has been added as content to the element.
 			// <html>, <head> and <body> are special elements with context constraints. They are already available in the document.
 			if (
-				(!config || config.contentModel !== HTMLElementConfigContentModelEnum.rawText) &&
+				(!config || (config.contentModel !== HTMLElementConfigContentModelEnum.rawText &&
+					config.contentModel !== HTMLElementConfigContentModelEnum.rcdata)) &&
 				this.nextElement !== documentElement &&
 				this.nextElement !== head &&
 				this.nextElement !== body
@@ -797,6 +812,11 @@ export default class HTMLParser {
 
 		// Plain text elements such as <script> and <style> should only contain text.
 		// Plain text elements should not decode entities. See #1564.
+		if (upperTagName === 'TEXTAREA' || upperTagName === 'TITLE') {
+			text = XMLEncodeUtility.decodeHTMLEntities(text.replace(/\r\n?/g, '\n').replace(/\0/g, '\uFFFD'));
+			// The tree builder ignores one leading LF in a textarea start tag.
+			if (upperTagName === 'TEXTAREA' && text.startsWith('\n')) text = text.slice(1);
+		}
 		this.currentNode![PropertySymbol.appendChild](this.rootDocument!.createTextNode(text), true);
 
 		const rawTextElement = this.currentNode;

package/vendor/happy-dom/packages/happy-dom/src/query-selector/SelectorParser.ts

@@ -46,7 +46,7 @@ const SELECTOR_GROUP_REGEXP = /(\\[0-9a-fA-F]{1,6}\s?|\\[\s\S])|(\s*[\s,+>~]\s*)
  * Group 23: Pseudo element (e.g. "::after", "::-webkit-inner-spin-button").
  */
 const SELECTOR_REGEXP =
-	/(\*)|((?:[a-zA-Z0-9\u00A0-\uFFFF-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)|#(([a-zA-Z0-9\u00A0-\uFFFF_-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)|\.(([a-zA-Z0-9\u00A0-\uFFFF_-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)|\[(([a-zA-Z0-9-_]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\]|\[(([a-zA-Z0-9-_]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\s*([~|^$*]{0,1})\s*=\s*("((?:[^"\\]|\\[\s\S])*)"|'((?:[^'\\]|\\[\s\S])*)')\s*(s|i){0,1}\]|\[(([a-zA-Z0-9-_]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\s*([~|^$*]{0,1})\s*=\s*(([a-zA-Z0-9\u00A0-\uFFFF_¤£-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\]|:([a-zA-Z-]+)\s*\(.+\)|:([a-zA-Z-]+)|::([a-zA-Z-]+)/g;
+	/(\*)|((?:[a-zA-Z0-9\u00A0-\uFFFF_-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)|#(([a-zA-Z0-9\u00A0-\uFFFF_-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)|\.(([a-zA-Z0-9\u00A0-\uFFFF_-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)|\[(([a-zA-Z0-9-_]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\]|\[(([a-zA-Z0-9-_]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\s*([~|^$*]{0,1})\s*=\s*("((?:[^"\\]|\\[\s\S])*)"|'((?:[^'\\]|\\[\s\S])*)')\s*(s|i){0,1}\]|\[(([a-zA-Z0-9-_]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\s*([~|^$*]{0,1})\s*=\s*(([a-zA-Z0-9\u00A0-\uFFFF_¤£-]|\\[0-9a-fA-F]{1,6}\s?|\\.)+)\]|:([a-zA-Z-]+)\s*\(.+\)|:([a-zA-Z-]+)|::([a-zA-Z-]+)/g;
 
 /**
  * Selector pseudo RegExp.

package/vendor/land-renderer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dr. John (醫者小智)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/land-renderer/README.md

@@ -0,0 +1,14 @@
+# Buninu Land renderer
+
+The renderer and its runtime dependencies are copied **unchanged** from
+`buninu-land` commit `3a42a5e315b351aa1e70459133df50541d5368e3` (MIT).
+
+Browser integration belongs in `lib/paint/direct-canvas.ts`, not in these
+vendored files. That adapter presents browser RGBA layers as Land surfaces;
+the compositor's channel-symmetric arithmetic preserves RGBA when supplied
+with an opaque RGBA background surface. No red/blue conversion is needed.
+
+`direct-compositor.ts` is the shared composition engine, including placement,
+cropping, scaling, opacity detection, geometry/word caches and occlusion.
+`renderer.ts` and its encoding/transport dependencies are included intact;
+browser screenshots retain the browser's existing CDP/encoding owner.