buninu-browser 0.7.0 → 0.9.1

package/frontends/wayland/win32-wire.js

@@ -0,0 +1,62 @@
+// A Windows-only envelope around unchanged Wayland bytes and FD argument order.
+// ACKs keep mapping names alive until the receiver has opened its own handles.
+export class MappingConnection {
+ constructor(resources,removed=()=>{}){
+  this.resources=resources;this.removed=removed;this.fds=[];this.input=Buffer.alloc(0);this.wire=Buffer.alloc(0);
+  this.output=[];this.queuedBytes=0;this.pending=new Map();this.next=1;this.closed=false;
+ }
+ attach(socket){this.socket=socket;this.flush()}
+ packet(meta,data=Buffer.alloc(0)){
+  const json=Buffer.from(JSON.stringify(meta)),body=Buffer.alloc(8+json.length+data.length);
+  body.writeUInt32LE(4+json.length+data.length);body.writeUInt32LE(json.length,4);json.copy(body,8);data.copy(body,8+json.length);
+  if(this.queuedBytes+body.length>4*1024*1024)throw Error('Output queue limit');
+  this.output.push(body);this.queuedBytes+=body.length;this.flush();
+ }
+ send(bytes,fds=[]){
+  if(this.closed)return;
+  if(this.pending.size>=256)throw Error('Resource ACK queue limit');
+  const held=[];
+  try{
+   for(const fd of fds)held.push(this.resources.sendResource(fd));
+   const id=this.next++;if(held.length)this.pending.set(id,held);
+   this.packet({version:1,id,resources:held.map(h=>h.descriptor)},bytes);
+  }catch(e){for(const h of held)h.release();this.close();throw e}
+ }
+ flush(){
+  try { while(!this.closed&&this.socket&&this.output.length){
+   const b=this.output[0],n=this.socket.write(b);if(n<0){this.close();return}if(!n)return;
+   this.queuedBytes-=n;if(n<b.length){this.output[0]=b.subarray(n);return}this.output.shift();
+  }} catch(error){this.error=error;this.close()}
+ }
+ receive(bytes){
+  try{
+   this.wire=Buffer.concat([this.wire,bytes]);
+   if(this.wire.length>2*1024*1024)throw Error('Input queue limit');
+   while(this.wire.length>=8){
+    const size=this.wire.readUInt32LE(),jsonSize=this.wire.readUInt32LE(4);
+    if(size<4||size>1024*1024||jsonSize>65536||jsonSize>size-4)throw Error('Invalid envelope');
+    if(this.wire.length<size+4)return;
+    const meta=JSON.parse(this.wire.subarray(8,8+jsonSize).toString()),data=this.wire.subarray(8+jsonSize,size+4);
+    this.wire=this.wire.subarray(size+4);
+    if(meta.version!==1)throw Error('Unknown mapping transport version');
+    if(meta.ack!==undefined){
+     const held=this.pending.get(meta.ack);if(!held||data.length)throw Error('Invalid resource ACK');
+     this.pending.delete(meta.ack);for(const h of held)h.release();continue;
+    }
+    if(!Number.isSafeInteger(meta.id)||!Array.isArray(meta.resources)||meta.resources.length>256)throw Error('Invalid resource packet');
+    for(const d of meta.resources)this.fds.push(this.resources.receiveResource(d));
+    if(meta.resources.length)this.packet({version:1,ack:meta.id});
+    this.input=Buffer.concat([this.input,data]);
+    if(this.input.length>1024*1024||this.fds.length>256)throw Error('Wayland queue limit');
+    this.onData?.();if(this.closed)return;
+   }
+  }catch(error){this.error=error;this.close()}
+ }
+ poll(){this.flush()}
+ close(){
+  if(this.closed)return;this.closed=true;try{this.socket?.end()}catch{}
+  for(const held of this.pending.values())for(const h of held)h.release();this.pending.clear();
+  for(const fd of this.fds)this.resources.closeResource(fd);this.fds=[];this.output=[];this.queuedBytes=0;
+  try{this.onClose?.()}finally{this.removed()}
+ }
+}

package/lib/audio/biquad.js

@@ -0,0 +1,25 @@
+// Web Audio / Audio EQ Cookbook normalized second-order filter coefficients.
+export function biquadCoefficients(type,frequency,q,gain,rate) {
+ const w=2*Math.PI*Math.max(0,Math.min(rate/2,frequency))/rate,c=Math.cos(w),s=Math.sin(w);
+ const A=10**(gain/40),alpha=s/(2*Math.max(1e-12,['lowpass','highpass'].includes(type)?10**(q/20):q));
+ let b0,b1,b2,a0=1+alpha,a1=-2*c,a2=1-alpha;
+ switch(type){
+ case 'lowpass':b0=(1-c)/2;b1=1-c;b2=b0;break;
+ case 'highpass':b0=(1+c)/2;b1=-(1+c);b2=b0;break;
+ case 'bandpass':b0=alpha;b1=0;b2=-alpha;break;
+ case 'notch':b0=1;b1=-2*c;b2=1;break;
+ case 'allpass':b0=1-alpha;b1=-2*c;b2=1+alpha;break;
+ case 'peaking':b0=1+alpha*A;b1=-2*c;b2=1-alpha*A;a0=1+alpha/A;a2=1-alpha/A;break;
+ case 'lowshelf':case 'highshelf':{
+  const t=Math.sqrt(2*A)*s;
+  if(type==='lowshelf'){
+   b0=A*((A+1)-(A-1)*c+t);b1=2*A*((A-1)-(A+1)*c);b2=A*((A+1)-(A-1)*c-t);
+   a0=(A+1)+(A-1)*c+t;a1=-2*((A-1)+(A+1)*c);a2=(A+1)+(A-1)*c-t;
+  }else{
+   b0=A*((A+1)+(A-1)*c+t);b1=-2*A*((A-1)+(A+1)*c);b2=A*((A+1)+(A-1)*c-t);
+   a0=(A+1)-(A-1)*c+t;a1=2*((A-1)-(A+1)*c);a2=(A+1)-(A-1)*c-t;
+  }break;
+ }
+ }
+ return [b0/a0,b1/a0,b2/a0,a1/a0,a2/a0];
+}

package/lib/audio/piano.js

@@ -4,8 +4,9 @@ import { floatToS16 } from "./pcm.js";
 // is relative to Space = MIDI 60 (C4). Change PIANO_DO alone to transpose
 // every key; the default A4 exactly matches LazyI's original octave.
 // The LazyI key intervals remain fixed in the table.
-// Browser control keys (Escape, Tab, CapsLock, Shift, Alt, Control, Backspace)
-// are intentionally omitted. Space and Enter remain playable as requested.
+// Left hand: Escape, `, Tab, CapsLock, ShiftLeft play a ii chord (re la re fa
+// la); AltRight (AltGr) continues . , m (do si la) down to sol. Other control
+// keys (right Shift, Alt, Control, Backspace) are intentionally omitted.
 export const PIANO_KEYS = Object.freeze({
   F1: 29, F2: 36, F3: 41, F4: 45, F5: 48, F6: 53,
   F7: 81, F8: 83, F9: 84, F10: 86, F11: 88, F12: 89,
@@ -17,6 +18,7 @@ export const PIANO_KEYS = Object.freeze({
   k: 64, l: 65, ";": 67, "'": 69, Enter: 71,
   z: 28, x: 35, c: 40, v: 43, b: 47, n: 67, m: 57,
   ",": 59, ".": 60, "/": 62, " ": 60,
+  Escape: 26, Tab: 38, CapsLock: 41, ShiftLeft: 45, AltRight: 55,
 });
 export const PIANO_DO = 69; // A4, LazyI's original Space pitch.
 
@@ -24,6 +26,7 @@ const CODE_KEYS = {
   Backquote: "`", Minus: "-", Equal: "=", BracketLeft: "[", BracketRight: "]",
   Backslash: "\\", Semicolon: ";", Quote: "'", Comma: ",", Period: ".", Slash: "/",
   Space: " ", NumpadEnter: "Enter",
+  Escape: "Escape", Tab: "Tab", CapsLock: "CapsLock", ShiftLeft: "ShiftLeft", AltRight: "AltRight",
 };
 const SHIFTED_KEYS = {
   "~": "`", "!": "1", "@": "2", "#": "3", "$": "4", "%": "5", "^": "6",
@@ -37,7 +40,7 @@ export function pianoNote(key, code = "") {
     : /^Digit[0-9]$/.test(code) ? code.slice(5)
       : CODE_KEYS[code] ?? (code.startsWith("F") ? code : null);
   const typed = key.length === 1 ? (SHIFTED_KEYS[key] ?? key.toLowerCase())
-    : key === "Space" || key === "Spacebar" ? " " : key;
+    : key === "Space" || key === "Spacebar" ? " " : key === "AltGraph" ? "AltRight" : key;
   const note = PIANO_KEYS[physical ?? typed];
   return note === undefined ? null : note + PIANO_DO - 60;
 }

package/lib/audio/playback-buffer.js

@@ -1,12 +1,12 @@
 // Decoded PCM kept in the controller is independent of the device queue.
 // It can bridge renderer work without increasing pause/seek output latency.
 export class PlaybackBuffer {
-  constructor(bytesPerSecond, frameBytes, leadSeconds) {
+  constructor(bytesPerSecond, frameBytes, leadSeconds, liveReserveSeconds = 0) {
     this.bytesPerSecond = bytesPerSecond;
     this.frameBytes = frameBytes;
-    this.reserve = leadSeconds <= 0.15 ? 0 : this.align(bytesPerSecond * 2);
-    this.threshold = this.reserve ? this.align(bytesPerSecond * 0.4) : 0;
-    this.buffering = Boolean(this.reserve);
+    this.reserve = this.align(bytesPerSecond * (leadSeconds <= 0.15 ? Math.max(0, Math.min(.5, liveReserveSeconds)) : 2));
+    this.threshold = leadSeconds <= 0.15 ? 0 : this.align(bytesPerSecond * 0.4);
+    this.buffering = Boolean(this.threshold);
   }
 
   align(bytes) {
@@ -14,7 +14,7 @@ export class PlaybackBuffer {
   }
 
   ready(queued, inDevice, finishing) {
-    if (!this.reserve || finishing) return true;
+    if (!this.threshold || finishing) return true;
     if (queued < this.frameBytes && inDevice < this.frameBytes) this.buffering = true;
     if (this.buffering && queued >= this.threshold) this.buffering = false;
     return !this.buffering;

package/lib/audio/pulse-client.js

@@ -259,7 +259,7 @@ export class PulseClient {
    * `onRequest(bytes)` asks for about that much more audio, paced to real time
    * (see PlaybackStream).
    */
-  async openPlayback({ rate, channels, name = "audio", onRequest = () => {}, onTiming = null, onTimingError = null, leadSeconds = LEAD_SECONDS }) {
+  async openPlayback({ rate, channels, name = "audio", onRequest = () => {}, onTiming = null, onTimingError = null, leadSeconds = LEAD_SECONDS, adaptiveLead = false }) {
     const spec = { format: SAMPLE_S16LE, channels, rate };
     const frameBytes = channels * 2;
     const bytesForSeconds = (seconds) => Math.max(frameBytes, Math.round(rate * seconds) * frameBytes);
@@ -267,7 +267,7 @@ export class PulseClient {
     // stream that is deliberately kept only 120 ms ahead would not start until
     // that buffer filled. Request an explicit, short start threshold instead.
     const interactive = leadSeconds <= 0.15;
-    const targetLength = bytesForSeconds(interactive ? 0.16 : 0.4);
+    const targetLength = bytesForSeconds(adaptiveLead ? 0.55 : interactive ? 0.16 : 0.4);
     const prebuffer = bytesForSeconds(interactive ? 0.04 : 0.08);
     const minimumRequest = bytesForSeconds(0.04);
     const reply = await this.#command(COMMAND.CREATE_PLAYBACK_STREAM, (w) => w
@@ -279,7 +279,7 @@ export class PulseClient {
     const index = reply.u32();
     reply.u32(); // sink input index
     const requested = reply.u32();
-    const stream = new PlaybackStream(this, index, spec, onRequest, leadSeconds, onTiming, onTimingError);
+    const stream = new PlaybackStream(this, index, spec, onRequest, leadSeconds, onTiming, onTimingError, adaptiveLead);
     this.#streams.set(index, stream);
     stream.grant(requested);
     return stream;
@@ -338,6 +338,9 @@ export class PulseClient {
  * the output. That reserve is discarded on close, not sent to the device.
  */
 const LEAD_SECONDS = 0.5;
+// Live synthesis keeps a small PCM reserve independent of server credits.
+// Unlike decoded media's two-second reserve, this has no startup threshold.
+const LIVE_RESERVE_SECONDS = 0.32;
 const PACE_MS = 50;
 // Video follows this measured clock. Sharing the 50 ms PCM timer would cap
 // presentation at 20 FPS even when decoding and output can keep up.
@@ -365,9 +368,11 @@ class PlaybackStream {
   #timingPending = false;
   #playedBytes = 0;
   #producerBuffer;
+  #adaptiveLead;
+  #requestedAt = null;
   killed = false;
 
-  constructor(client, index, { rate, channels }, onRequest, leadSeconds, onTiming, onTimingError) {
+  constructor(client, index, { rate, channels }, onRequest, leadSeconds, onTiming, onTimingError, adaptiveLead) {
     this.#client = client;
     this.index = index;
     // Audio is only ever cut at whole frames (one sample of every channel):
@@ -377,7 +382,8 @@ class PlaybackStream {
     this.#bytesPerSecond = rate * this.#frameBytes;
     this.#onRequest = onRequest;
     this.#leadSeconds = leadSeconds;
-    this.#producerBuffer = new PlaybackBuffer(this.#bytesPerSecond, this.#frameBytes, leadSeconds);
+    this.#adaptiveLead = adaptiveLead;
+    this.#producerBuffer = new PlaybackBuffer(this.#bytesPerSecond, this.#frameBytes, leadSeconds, adaptiveLead ? LIVE_RESERVE_SECONDS : 0);
     this.#onTiming = onTiming;
     this.#onTimingError = onTimingError;
     this.#timer = setInterval(() => this.#pace(), PACE_MS);
@@ -414,7 +420,19 @@ class PlaybackStream {
   /** Queues s16le audio from the producer; it goes out as the clock allows. */
   write(bytes) {
     if (this.killed || !bytes.length) return;
+    if (this.#adaptiveLead && this.#requestedAt !== null) {
+      // Live synthesis runs in the page renderer. Learn its response budget
+      // under expensive Canvas/JS work without pre-rendering seconds of future
+      // input. The separate controller can play this bounded device queue.
+      const responseSeconds=(performance.now()-this.#requestedAt)/1000;
+      if(responseSeconds>this.#leadSeconds-0.05)
+        this.#leadSeconds=Math.min(0.5,Math.max(this.#leadSeconds,responseSeconds+0.1));
+      // Later pieces intentionally yield for page scheduling; measure only
+      // the first response, not the time to complete the entire reserve.
+      this.#requestedAt=null;
+    }
     this.#outstanding = Math.max(0, this.#outstanding - bytes.length);
+    if (!this.#outstanding) this.#requestedAt=null;
     this.#queue.push(bytes);
     this.#queuedBytes += bytes.length;
     this.#pace();
@@ -472,6 +490,7 @@ class PlaybackStream {
     const sentNow = inDevice + this.#offset - previousOffset;
     const need = this.#producerBuffer.request(this.#queuedBytes, this.#outstanding, sentNow, immediateNeed);
     if (need >= this.#bytesPerSecond * MIN_REQUEST_SECONDS && !this.finishing) {
+      this.#requestedAt ??= performance.now();
       this.#outstanding += need;
       this.#onRequest(need);
     }