buninu-browser 0.7.0 → 0.9.0

package/AGENTS.md

@@ -1,6 +1,10 @@
 # AGENTS
 
 ## General
+- Never EVER EVER EVER EVER use hardlinks.
+- Hardlinks are not allowed.
+- Using hardlinks is utterly harmful.
+- .
 - This project only uses pure JavaScript +/- WASM.
 - Native bindings are generally not allowed in the headless shell itself
   * In the future when it is wrapped into a full browser on each platform, the frontend should stay as thin wrappers just enough to draw rendered content from the headlesss shell
@@ -14,6 +18,7 @@
 ## Implementing the browser
 - Do not treat any website specially when refining browser features like layout css js. Fix the actual problem that all websites can benefit from.
 - If you don't know how to fix a specific bug, look at ../chromium implementation but don't copy LGPL code.
+- The graphics rendering of this browser should ensure CPU runs first. GPU acceleration must only be optional.
 
 ## Viewing files
 - No file is unviewable: every response the browser navigates to must show something, never a "cannot be shown" page

package/README.md

@@ -50,13 +50,17 @@ npx buninu-browser github.com \
 # The engine alone, as a CDP
 # endpoint for any client
 npx buninu-browser --headless \
-  --remote-debugging-port=9222
+  --remote-debugging-port=9222 --window-size=1280,800
 
 # capture a page and exit
 npx buninu-browser --headless --screenshot=page.png \
   --window-size=1280,800 https://example.com
 ```
 
+`--window-size=WIDTH,HEIGHT` sets the initial viewport for both headless CDP
+and screenshot modes (default 800×600 CSS pixels, DPR 1). CDP clients can
+subsequently change it with `Emulation.setDeviceMetricsOverride`.
+
 Screenshot mode waits for the page's `load` event before capture. For content
 that appears later, add `--screenshot-wait=1000` (real milliseconds). The output
 format follows the filename extension: PNG, JPEG, or WebP. Chromium's
@@ -108,6 +112,27 @@ the rest is passed on:
 casty's and the engine's options:
 `--casty --help`, `--headless --help`.
 
+### JavaScript dialogs
+
+`alert()`, `confirm()` and `prompt()` show a browser-owned modal dialog in the
+page image, including through Casty and the Wayland frontend. For example,
+enter `javascript:alert(1+2)` in the address bar. Alert has an OK button;
+confirm and prompt also have Cancel. Enter accepts, Escape dismisses, and
+prompt initially selects its default text. Long messages scroll and their
+text can be selected and copied. Page scripts wait synchronously for the
+answer; confirm returns a boolean and a cancelled prompt returns `null`.
+The dialog lives in a separate renderer, outside the page's DOM and realm.
+
+CDP exposes `Page.javascriptDialogOpening`, `Page.javascriptDialogClosed`
+and `Page.handleJavaScriptDialog` for automation. Ordinary pointer and
+keyboard input can also operate the displayed dialog.
+
+File inputs also use a browser-owned chooser: click folders or enter a folder
+path, select files, then Open (or Cancel/Escape). Multiple selection and
+asynchronous `FileReader` are supported. Only selected file contents and names
+reach the page, not their host paths. The current chooser accepts at most
+32 MiB per selection; it does not yet filter the listing by `accept`.
+
 ### Websites with self-signed certificates
 
 To browse a website with an untrusted self-signed HTTPS certificate, set
@@ -360,6 +385,36 @@ Documents load in stages:
 are reported over CDP when the page reaches them. Every visible change
 pushes a screencast frame.
 
+### Experimental CPU WebGL
+
+`canvas.getContext('webgl')` has a software-only triangle rendering subset for
+basic Three.js scenes. It uses the bundled CanvasKit shader compiler, with a
+bounded numeric JavaScript shader path for supported expressions. Unsupported
+numeric syntax keeps the CanvasKit path. It does not require a GPU or a new
+native dependency. Depth testing, perspective varyings and basic 2D image/canvas
+textures are supported; this is not a conformant or complete WebGL implementation
+(framebuffers, cube maps, mipmaps and general blending remain incomplete).
+
+The renderer defers unobserved draws, caches exact geometry/shading results while
+reapplying current depth, and skips polygon clipping for meshes wholly inside
+the view. CSS rotation, canvas-local pointer coordinates, HTML drag events and
+detached image loading use the ordinary browser paths rather than Three.js
+special cases.
+
+The interactive reference is the [Three.js stereo scene](https://drjohnjstest.blogspot.com/2023/11/3dsbsthreejsdemo.html).
+Run `bun test/manual-threejs-scene.js` for its buttons, prompt, orientation and
+drag checks. Pass a folder containing `floor.jpg` and `wall.jpg` to also exercise
+the file chooser and room textures; optional `小凱L.png` / `小凱R.png` exercise
+stereo-image import. A second argument sets the output directory. This network
+check is separate from `bun test`; Copy was also checked through the existing
+browser clipboard callback without replacing the user's clipboard.
+
+For completed-frame timings, run
+`bun test/manual-webgl-benchmark.js buninu /path/to/assets`; replace `buninu`
+with `chromium` for a reference (select a software Vulkan ICD when comparing CPU
+rendering). It records both canvas sizes, frame times and a screenshot. These
+timings exclude CDP screenshot encoding and terminal presentation.
+
 ### Mobile presentation
 
 Pages see a desktop browser unless `--mobile` is given. With it, requests
@@ -439,6 +494,40 @@ additional unreported downstream latency, such as Bluetooth output latency.
 With `BUNINU_LOG`, `media sync` records reported audio progress, the latest
 rendered video position, and the output queue/latency for diagnosis.
 
+### Web Audio synthesis and sample playback
+
+The initial [Web Audio](https://www.w3.org/TR/webaudio-1.1/) subset provides
+`AudioContext` (`webkitAudioContext` is an alias), `OscillatorNode`, `GainNode`
+and `AudioParam` scheduling. Sine, square, sawtooth and triangle oscillators
+are synthesized in JavaScript in 128-sample blocks. Connected voices share
+one stereo PCM stream per context through the existing audio output above;
+no GPU or additional native library is needed. Suspend, close and navigation
+release the context's output. `AudioBuffer`, `createBuffer()`,
+`decodeAudioData()` and `AudioBufferSourceNode` support decoded sample playback,
+offsets, duration, looping, rate/detune and ended events. Compressed audio uses
+the existing WASM decoder and is resampled to the context rate; the current
+software graph downmixes buffer channels before stereo output. Offline contexts,
+filters and AudioWorklets are not implemented yet.
+
+[Clumsy Bird](https://ellisonleao.github.io/clumsy-bird/) is an interactive
+reference for sample playback, Canvas image patterns, detached image dimensions
+and page-local primitive prototype extensions. Start with a click or Space;
+Space also makes the bird fly. The page remains under SES and the renderer's
+seccomp policy; shared host prototypes are not unfrozen. Prototype extension
+methods belong to the page and are discarded on navigation. The live check
+`bun test/manual-clumsy-bird.js buninu /tmp/clumsy-bird` records menu and gameplay
+screenshots and verifies pointer/Space input with the ordinary headless backend.
+
+The interactive reference is the [text-to-numbered musical notation page](https://drjohnjstest.blogspot.com/2023/10/text-to-numbered-musical-notation.html).
+Its Play button and two-part playback use changing oscillator frequencies.
+To run the live reference test, including a screenshot:
+
+```sh
+bun test/manual-numbered-music.js buninu /tmp/numbered-music
+# Optional comparison; requires /usr/local/bin/chromium-headless-shell.
+bun test/manual-numbered-music.js chromium /tmp/numbered-music-chromium
+```
+
 ### Render scheduling
 
 Set `BUNINU_RENDER_MIN_INTERVAL` to adjust the minimum delay before coalesced

package/buninu-browser.js

@@ -50,7 +50,7 @@ Options:
   --chromium                      Use the previous desktop Chromium compatibility identity
                                   Last desktop identity flag wins; --mobile takes priority
   --screenshot[=FILE]             Capture one PNG and exit (default screenshot.png)
-  --window-size=WIDTH,HEIGHT      Viewport size for the screenshot (default 800,600)
+  --window-size=WIDTH,HEIGHT      Initial viewport size in CSS pixels (default 800,600)
   --screenshot-wait=MILLISECONDS  Wait after page load before capturing
   --version, -V                   Print the version
   --help, -h                      Print this help

package/frontends/wayland/README.md

@@ -8,8 +8,8 @@ bun index.js --wayland https://example.com --window-size=800,600
 ```
 
 Uses the existing browser controller and renderer. No Qt, libwayland, native addon,
-new dependency, PNG encoding, or base64. Only libc is loaded, because Bun sockets
-cannot send/receive SCM_RIGHTS ancillary file descriptors. Linux/Android 64-bit only.
+new dependency, PNG encoding, or base64. Linux/Android 64-bit uses libc for
+SCM_RIGHTS ancillary file descriptors. Windows uses the named mapping transport below.
 The default launcher remains Casty. External integration blocks in index.js are
 marked `wayland handle`; the frontend lives entirely in this directory.
 
@@ -150,3 +150,36 @@ The page includes vertical/horizontal/two-axis scroll boxes, button and double-c
 counters, a drag canvas, text controls and bounded event logs. It reports received
 modifiers without swapping wheel axes itself. 頁面不自行轉換滾輪方向，可從紀錄
 確認外層是否真的送來水平軸與修飾鍵；預設 Casty 路徑可省略 `--wayland`。
+
+## Windows named mappings / Windows 具名共享記憶體 (unstable)
+
+**unstable.** Experimental Windows-to-Windows transport; native Windows verification is still
+required. Start Land with `bun index.js --win32` in the Land directory, then run
+`bun index.js --wayland URL` here with `WAYLAND_DISPLAY=wayland-buninu` (or the
+socket name printed by Land). Both processes must use the same Windows session
+and runtime directory: `XDG_RUNTIME_DIR`, then `TMPDIR`, then system temp.
+For example, in PowerShell before starting each process:
+
+```powershell
+$env:XDG_RUNTIME_DIR = $env:TEMP
+$env:WAYLAND_DISPLAY = "wayland-buninu"
+```
+
+Only `process.platform === 'win32'` imports the Windows backend and loads
+`kernel32.dll`. `CreateFileMappingW` / `OpenFileMappingW` / `MapViewOfFile` provide
+pagefile-backed `Local\buninu-wayland-UUID` resources. No per-frame pixel file,
+PNG, base64 or pixel socket upload is used. Wayland bytes and FD argument order
+stay unchanged inside a versioned socket envelope carrying mapping descriptors.
+An ACK retains the sender's mapping handle until the receiver has opened it.
+Existing commit/release synchronization protects reusable pixel buffers. Keymaps
+use byte mappings; bounded clipboard pipes use mappings with an atomic length
+and EOF header. Disconnection releases pending handles and queued resources.
+This envelope is private to these two Windows implementations; it is not the
+standard SCM_RIGHTS wire transport. Linux/Android continue to use that original
+transport, and Windows does not advertise DMA-BUF support.
+
+Windows 驗證：在本專案執行 `bun test test/wayland-win32-resources.test.js`，
+測試跨程序共享像素、剪貼板 pipe 的 EOF，以及原本 socket 路徑上的具名資源傳遞。
+其他平台會略過這些原生測試；封裝、分段收送、ACK 和清理測試可在各平台執行：
+`bun test test/wayland-win32-wire.test.js`。PowerShell 剪貼板沿用原有 jsmdcui
+函式，仍優先嘗試 xclip，失敗才 fallback。

package/frontends/wayland/client.js

@@ -1,13 +1,14 @@
 import {join,isAbsolute} from 'node:path';
 import {tmpdir} from 'node:os';
-import {openSync,closeSync,ftruncateSync,unlinkSync,writeSync} from 'node:fs';
-import {connectUnix} from './transport.js';
+import {openSync,ftruncateSync,unlinkSync} from 'node:fs';
+import {closeSync,writeSync} from './resource-io.js';
+import {connectUnix,libc} from './transport.js';
 import {interfaces,decode,encodeRequest} from './protocol.js';
 
 export class WaylandClient {
   constructor(path) {
     const display=process.env.WAYLAND_DISPLAY || 'wayland-0';
-    this.connection=connectUnix(path || (isAbsolute(display)?display:join(process.env.XDG_RUNTIME_DIR||tmpdir(),display)));
+    this.connection=connectUnix(path || (isAbsolute(display)?display:join(process.env.XDG_RUNTIME_DIR||process.env.TMPDIR||tmpdir(),display)));
     this.objects=new Map();this.nextId=2;this.globals=new Map();this.waiters=new Set();
     this.objects.set(1,{iface:'wl_display',event:(name,args)=>{
       if(name==='error')throw Error(`Wayland error ${args.join(': ')}`);
@@ -70,9 +71,10 @@ export class WaylandWindow {
     for(const b of [...this.buffers])if(!b.busy&&(b.width!==width||b.height!==height))this.disposeBuffer(b);
     let b=this.buffers.find(b=>!b.busy);
     if(!b){
-      const path=join(process.env.XDG_RUNTIME_DIR||tmpdir(),`buninu-shm-${process.pid}-${crypto.randomUUID()}`);
-      const fd=openSync(path,'wx+',0o600);unlinkSync(path);
-      try{ftruncateSync(fd,size);
+      const path=join(process.env.XDG_RUNTIME_DIR||process.env.TMPDIR||tmpdir(),`buninu-shm-${process.pid}-${crypto.randomUUID()}`);
+      const fd=process.platform==='win32'?libc.createMapping(size):openSync(path,'wx+',0o600);
+      if(process.platform!=='win32')unlinkSync(path);
+      try{if(process.platform!=='win32')ftruncateSync(fd,size);
         b={fd,width,height,busy:false};const pool=c.object('wl_shm_pool');c.request(c.shm,'create_pool',pool,fd,size);
         b.id=c.object('wl_buffer',(event)=>{if(event==='release'){b.busy=false;this.onReady?.();}});
         c.request(pool,'create_buffer',b.id,0,width,height,width*4,1);c.request(pool,'destroy');this.buffers.push(b);

package/frontends/wayland/clipboard.js

@@ -1,5 +1,5 @@
 // A standard wl_data_device text client. Only explicit copy/paste transfers bytes.
-import {readSync, writeSync} from 'node:fs';
+import {readSync, writeSync} from './resource-io.js';
 import {libc} from './transport.js';
 const mimeTypes=['text/plain;charset=utf-8','text/plain','UTF8_STRING','STRING'];
 const limit=1024*1024;

package/frontends/wayland/index.js

@@ -121,7 +121,7 @@ export async function launch({url='about:blank',width=800,height=600,socket,chro
 }
 if(import.meta.main){
   const args=Bun.argv.slice(2).filter(a=>a!=='--');
-  if(args.some(a=>['-h','--help'].includes(a))){console.log('Usage: buninu-browser --wayland [URL or file] [--window-size=800,600]\nUses WAYLAND_DISPLAY and XDG_RUNTIME_DIR. Experimental wl_shm frontend.');process.exit(0);}
+  if(args.some(a=>['-h','--help'].includes(a))){console.log('Usage: buninu-browser --wayland [URL or file] [--window-size=800,600]\nUses WAYLAND_DISPLAY; socket directory: XDG_RUNTIME_DIR, TMPDIR, system temp. Experimental wl_shm frontend.');process.exit(0);}
   let width=800,height=600,url='about:blank';
   for(const arg of args){if(arg.startsWith('--window-size=')){[width,height]=arg.slice(14).split(',').map(Number);}else if(arg.startsWith('-'))throw Error(`Unknown Wayland option: ${arg}`);else url=arg;}
   if(!Number.isInteger(width)||!Number.isInteger(height)||width<1||height<1||width>8192||height>8192)throw Error('Invalid window size');

package/frontends/wayland/input.js

@@ -1,4 +1,4 @@
-import {readSync} from 'node:fs';
+import {readSync} from './resource-io.js';
 import {libc} from './transport.js';
 
 // A deliberately bounded XKB subset, not a replacement for libxkbcommon.

package/frontends/wayland/resource-io.js

@@ -0,0 +1,6 @@
+// Native fs descriptors on POSIX; named-mapping resource IDs on Windows.
+import * as fs from 'node:fs';
+const mapping = process.platform === 'win32' ? await import('./win32-resources.js') : null;
+export const readSync = mapping?.readResource ?? fs.readSync;
+export const writeSync = mapping?.writeResource ?? fs.writeSync;
+export const closeSync = mapping?.closeResource ?? fs.closeSync;

package/frontends/wayland/transport-posix.js

@@ -0,0 +1,120 @@
+// Adapted from buninu-land/lib/transport.js (MIT; LICENSE-land).
+// Linux 64-bit ABI. Only libc is loaded. recvmsg is required for SCM_RIGHTS;
+// Bun's stream sockets do not expose ancillary file descriptors.
+import { dlopen, ptr } from 'bun:ffi';
+
+if (!['arm64', 'x64'].includes(process.arch) || !['linux', 'android'].includes(process.platform)) throw Error('Requires 64-bit Linux or Android');
+const signature = (args, returns = 'i32') => ({ args, returns });
+let library;
+let errnoSymbol;
+// Same architecture-specific libc names as buninu-linux's /lib/dlopen.js.
+const muslLibc = `libc.musl-${process.arch === 'arm64' ? 'aarch64' : 'x86_64'}.so.1`;
+const candidates = process.platform === 'android'
+  ? [['libc.so', '__errno']]
+  : [
+      ['libc.so.6', '__errno_location'],
+      [muslLibc, '__errno_location'],
+      [`/lib/${muslLibc}`, '__errno_location'],
+      ['libc.so', '__errno_location'],
+      ['libc.so', '__errno'],
+    ];
+const failures = [];
+for (const [name, symbol] of candidates) {
+  try { library = dlopen(name, {
+    connect: signature(['i32','ptr','u32']), socket: signature(['i32','i32','i32']),
+    recvmsg: signature(['i32','ptr','i32'], 'i64'), sendmsg: signature(['i32','ptr','i32'], 'i64'),
+    dup: signature(['i32']), send: signature(['i32','ptr','u64','i32'], 'i64'), close: signature(['i32']),
+
+    // Standard Wayland clipboard FD transfer.
+    pipe2: signature(['ptr','i32']), fcntl: signature(['i32','i32','i32']),
+
+    [symbol]: signature([], 'ptr'),
+  }); errnoSymbol = symbol; break; }
+  catch (error) { failures.push(`${name} (${symbol}): ${error.message}`); }
+}
+if (!library) throw Error(`Cannot load libc on ${process.platform}:\n${failures.join('\n')}`);
+export const libc = library.symbols;
+import { toArrayBuffer } from 'bun:ffi';
+export const errno = () => new Int32Array(toArrayBuffer(libc[errnoSymbol](), 0, 4))[0];
+const retry = () => [4,11].includes(errno());
+export class Connection {
+  constructor(fd, removed) {
+    this.fd = fd; this.removed = removed; this.fds = []; this.input = Buffer.alloc(0); this.output = []; this.queuedBytes = 0;
+    this.data = Buffer.alloc(65536); this.control = Buffer.alloc(4096); this.iov = Buffer.alloc(16); this.msg = Buffer.alloc(56);
+    this.iov.writeBigUInt64LE(BigInt(ptr(this.data))); this.iov.writeBigUInt64LE(BigInt(this.data.length), 8);
+    this.msg.writeBigUInt64LE(BigInt(ptr(this.iov)), 16); this.msg.writeBigUInt64LE(1n, 24);
+    this.msg.writeBigUInt64LE(BigInt(ptr(this.control)), 32);
+  }
+  send(bytes, fds = []) {
+    if (this.closed) return;
+    const owned = [];
+    try { for (const fd of fds) { const copy = libc.dup(fd); if (copy < 0) throw Error('Cannot duplicate outgoing FD'); owned.push(copy); } }
+    catch (e) { for (const fd of owned) libc.close(fd); throw e; }
+    this.output.push({ bytes, fds: owned }); this.queuedBytes += bytes.length;
+    if (this.queuedBytes > 4*1024*1024) this.close();
+  }
+  flush() {
+    for (let round = 0; round < 64 && this.output.length; round++) {
+      const item = this.output[0];
+      let n;
+      if (item.fds.length) {
+        const iov = Buffer.alloc(16), msg = Buffer.alloc(56);
+        const size = 16 + item.fds.length * 4, control = Buffer.alloc(Math.ceil(size / 8) * 8);
+        iov.writeBigUInt64LE(BigInt(ptr(item.bytes))); iov.writeBigUInt64LE(BigInt(item.bytes.length), 8);
+        control.writeBigUInt64LE(BigInt(size)); control.writeInt32LE(1,8); control.writeInt32LE(1,12);
+        item.fds.forEach((fd,i) => control.writeInt32LE(fd,16+i*4));
+        msg.writeBigUInt64LE(BigInt(ptr(iov)),16); msg.writeBigUInt64LE(1n,24);
+        msg.writeBigUInt64LE(BigInt(ptr(control)),32); msg.writeBigUInt64LE(BigInt(control.length),40);
+        n = Number(libc.sendmsg(this.fd,msg,0x4000));
+      } else n = Number(libc.send(this.fd,item.bytes,item.bytes.length,0x4000));
+      if (n < 0) { if (!retry()) this.close(); return; }
+      if (!n) return this.close();
+      // SCM_RIGHTS is delivered with the first successfully sent byte, even on partial writes.
+      for (const fd of item.fds) libc.close(fd); item.fds = [];
+      this.queuedBytes -= n;
+      if (n === item.bytes.length) this.output.shift(); else item.bytes = item.bytes.subarray(n);
+    }
+  }
+  poll() {
+    if (this.closed) return;
+    try {
+      for (let round = 0; round < 16; round++) {
+        this.msg.writeBigUInt64LE(BigInt(this.control.length), 40); this.msg.writeUInt32LE(0, 48);
+        const n = Number(libc.recvmsg(this.fd, this.msg, 0x40000000));
+        if (n < 0) { if (retry()) break; return this.close(); }
+        if (!n) return this.close();
+        const end = Number(this.msg.readBigUInt64LE(40));
+        for (let p = 0; p + 16 <= end;) {
+          const size = Number(this.control.readBigUInt64LE(p)); if (size < 16 || p + size > end) throw Error('Invalid ancillary data');
+          if (this.control.readInt32LE(p+8) === 1 && this.control.readInt32LE(p+12) === 1)
+            for (let q = p + 16; q + 4 <= p + size; q += 4) this.fds.push(this.control.readInt32LE(q));
+          p += Math.ceil(size / 8) * 8;
+        }
+        if (this.msg.readUInt32LE(48) & 8) throw Error('Truncated ancillary data');
+        this.input = Buffer.concat([this.input, this.data.subarray(0,n)]);
+        if (this.input.length > 1024*1024 || this.fds.length > 256) throw Error('Client queue limit');
+        this.onData();
+        if (this.closed) return;
+      }
+      this.flush();
+    } catch (e) { console.error(`Wayland client: ${e.message}`);
+      // Flush queued requests before disconnecting.
+      this.flush();
+      this.close(); }
+  }
+  close() {
+    if (this.closed) return; this.closed = true; libc.close(this.fd);
+    for (const item of this.output) for (const fd of item.fds) libc.close(fd);
+    this.output = []; this.queuedBytes = 0;
+    for (const fd of this.fds) libc.close(fd); this.fds = []; this.onClose?.(); this.removed();
+  }
+}
+
+export function connectUnix(path) {
+  if (Buffer.byteLength(path)>107 || path.includes('\0')) throw Error('Invalid Wayland socket path');
+  const fd=libc.socket(1,1|0x800|0x80000,0);
+  if(fd<0)throw Error(`socket: errno ${errno()}`);
+  const address=Buffer.alloc(110); address.writeUInt16LE(1);address.write(path,2);
+  if(libc.connect(fd,address,Buffer.byteLength(path)+3)<0){const code=errno();libc.close(fd);throw Error(`connect ${path}: errno ${code}`);}
+  return new Connection(fd,()=>{});
+}

package/frontends/wayland/transport-win32.js

@@ -0,0 +1,9 @@
+import * as resources from './win32-resources.js';
+import {MappingConnection} from './win32-wire.js';
+export const {libc,errno}=resources;
+export const Connection=MappingConnection;
+export function connectUnix(path){
+ const c=new MappingConnection(resources);
+ Bun.connect({unix:path,socket:{open:s=>c.attach(s),data:(_,b)=>c.receive(b),drain:()=>c.flush(),close:()=>c.close(),error:(_,e)=>{c.error=e;c.close()}}}).catch(e=>{c.error=e;c.close()});
+ return c;
+}

package/frontends/wayland/transport.js

@@ -1,120 +1,3 @@
-// Adapted from buninu-land/lib/transport.js (MIT; LICENSE-land).
-// Linux 64-bit ABI. Only libc is loaded. recvmsg is required for SCM_RIGHTS;
-// Bun's stream sockets do not expose ancillary file descriptors.
-import { dlopen, ptr } from 'bun:ffi';
-
-if (!['arm64', 'x64'].includes(process.arch) || !['linux', 'android'].includes(process.platform)) throw Error('Requires 64-bit Linux or Android');
-const signature = (args, returns = 'i32') => ({ args, returns });
-let library;
-let errnoSymbol;
-// Same architecture-specific libc names as buninu-linux's /lib/dlopen.js.
-const muslLibc = `libc.musl-${process.arch === 'arm64' ? 'aarch64' : 'x86_64'}.so.1`;
-const candidates = process.platform === 'android'
-  ? [['libc.so', '__errno']]
-  : [
-      ['libc.so.6', '__errno_location'],
-      [muslLibc, '__errno_location'],
-      [`/lib/${muslLibc}`, '__errno_location'],
-      ['libc.so', '__errno_location'],
-      ['libc.so', '__errno'],
-    ];
-const failures = [];
-for (const [name, symbol] of candidates) {
-  try { library = dlopen(name, {
-    connect: signature(['i32','ptr','u32']), socket: signature(['i32','i32','i32']),
-    recvmsg: signature(['i32','ptr','i32'], 'i64'), sendmsg: signature(['i32','ptr','i32'], 'i64'),
-    dup: signature(['i32']), send: signature(['i32','ptr','u64','i32'], 'i64'), close: signature(['i32']),
-
-    // Standard Wayland clipboard FD transfer.
-    pipe2: signature(['ptr','i32']), fcntl: signature(['i32','i32','i32']),
-
-    [symbol]: signature([], 'ptr'),
-  }); errnoSymbol = symbol; break; }
-  catch (error) { failures.push(`${name} (${symbol}): ${error.message}`); }
-}
-if (!library) throw Error(`Cannot load libc on ${process.platform}:\n${failures.join('\n')}`);
-export const libc = library.symbols;
-import { toArrayBuffer } from 'bun:ffi';
-export const errno = () => new Int32Array(toArrayBuffer(libc[errnoSymbol](), 0, 4))[0];
-const retry = () => [4,11].includes(errno());
-export class Connection {
-  constructor(fd, removed) {
-    this.fd = fd; this.removed = removed; this.fds = []; this.input = Buffer.alloc(0); this.output = []; this.queuedBytes = 0;
-    this.data = Buffer.alloc(65536); this.control = Buffer.alloc(4096); this.iov = Buffer.alloc(16); this.msg = Buffer.alloc(56);
-    this.iov.writeBigUInt64LE(BigInt(ptr(this.data))); this.iov.writeBigUInt64LE(BigInt(this.data.length), 8);
-    this.msg.writeBigUInt64LE(BigInt(ptr(this.iov)), 16); this.msg.writeBigUInt64LE(1n, 24);
-    this.msg.writeBigUInt64LE(BigInt(ptr(this.control)), 32);
-  }
-  send(bytes, fds = []) {
-    if (this.closed) return;
-    const owned = [];
-    try { for (const fd of fds) { const copy = libc.dup(fd); if (copy < 0) throw Error('Cannot duplicate outgoing FD'); owned.push(copy); } }
-    catch (e) { for (const fd of owned) libc.close(fd); throw e; }
-    this.output.push({ bytes, fds: owned }); this.queuedBytes += bytes.length;
-    if (this.queuedBytes > 4*1024*1024) this.close();
-  }
-  flush() {
-    for (let round = 0; round < 64 && this.output.length; round++) {
-      const item = this.output[0];
-      let n;
-      if (item.fds.length) {
-        const iov = Buffer.alloc(16), msg = Buffer.alloc(56);
-        const size = 16 + item.fds.length * 4, control = Buffer.alloc(Math.ceil(size / 8) * 8);
-        iov.writeBigUInt64LE(BigInt(ptr(item.bytes))); iov.writeBigUInt64LE(BigInt(item.bytes.length), 8);
-        control.writeBigUInt64LE(BigInt(size)); control.writeInt32LE(1,8); control.writeInt32LE(1,12);
-        item.fds.forEach((fd,i) => control.writeInt32LE(fd,16+i*4));
-        msg.writeBigUInt64LE(BigInt(ptr(iov)),16); msg.writeBigUInt64LE(1n,24);
-        msg.writeBigUInt64LE(BigInt(ptr(control)),32); msg.writeBigUInt64LE(BigInt(control.length),40);
-        n = Number(libc.sendmsg(this.fd,msg,0x4000));
-      } else n = Number(libc.send(this.fd,item.bytes,item.bytes.length,0x4000));
-      if (n < 0) { if (!retry()) this.close(); return; }
-      if (!n) return this.close();
-      // SCM_RIGHTS is delivered with the first successfully sent byte, even on partial writes.
-      for (const fd of item.fds) libc.close(fd); item.fds = [];
-      this.queuedBytes -= n;
-      if (n === item.bytes.length) this.output.shift(); else item.bytes = item.bytes.subarray(n);
-    }
-  }
-  poll() {
-    if (this.closed) return;
-    try {
-      for (let round = 0; round < 16; round++) {
-        this.msg.writeBigUInt64LE(BigInt(this.control.length), 40); this.msg.writeUInt32LE(0, 48);
-        const n = Number(libc.recvmsg(this.fd, this.msg, 0x40000000));
-        if (n < 0) { if (retry()) break; return this.close(); }
-        if (!n) return this.close();
-        const end = Number(this.msg.readBigUInt64LE(40));
-        for (let p = 0; p + 16 <= end;) {
-          const size = Number(this.control.readBigUInt64LE(p)); if (size < 16 || p + size > end) throw Error('Invalid ancillary data');
-          if (this.control.readInt32LE(p+8) === 1 && this.control.readInt32LE(p+12) === 1)
-            for (let q = p + 16; q + 4 <= p + size; q += 4) this.fds.push(this.control.readInt32LE(q));
-          p += Math.ceil(size / 8) * 8;
-        }
-        if (this.msg.readUInt32LE(48) & 8) throw Error('Truncated ancillary data');
-        this.input = Buffer.concat([this.input, this.data.subarray(0,n)]);
-        if (this.input.length > 1024*1024 || this.fds.length > 256) throw Error('Client queue limit');
-        this.onData();
-        if (this.closed) return;
-      }
-      this.flush();
-    } catch (e) { console.error(`Wayland client: ${e.message}`);
-      // Flush queued requests before disconnecting.
-      this.flush();
-      this.close(); }
-  }
-  close() {
-    if (this.closed) return; this.closed = true; libc.close(this.fd);
-    for (const item of this.output) for (const fd of item.fds) libc.close(fd);
-    this.output = []; this.queuedBytes = 0;
-    for (const fd of this.fds) libc.close(fd); this.fds = []; this.onClose?.(); this.removed();
-  }
-}
-
-export function connectUnix(path) {
-  if (Buffer.byteLength(path)>107 || path.includes('\0')) throw Error('Invalid Wayland socket path');
-  const fd=libc.socket(1,1|0x800|0x80000,0);
-  if(fd<0)throw Error(`socket: errno ${errno()}`);
-  const address=Buffer.alloc(110); address.writeUInt16LE(1);address.write(path,2);
-  if(libc.connect(fd,address,Buffer.byteLength(path)+3)<0){const code=errno();libc.close(fd);throw Error(`connect ${path}: errno ${code}`);}
-  return new Connection(fd,()=>{});
-}
+// Platform selection must precede loading any native library.
+const backend = await import(process.platform === 'win32' ? './transport-win32.js' : './transport-posix.js');
+export const {libc,errno,Connection,connectUnix} = backend;

package/frontends/wayland/win32-resources.js

@@ -0,0 +1,80 @@
+// Windows-only named pagefile mappings. No DLL is loaded on other platforms.
+import {dlopen,toArrayBuffer} from 'bun:ffi';
+import {fstatSync,readSync,writeSync,closeSync} from 'node:fs';
+if(process.platform!=='win32')throw Error('Named mappings require Windows');
+const sig=(args,returns)=>({args,returns});
+const {symbols:k}=dlopen('kernel32.dll',{
+ CreateFileMappingW:sig(['i64','ptr','u32','u32','u32','ptr'],'ptr'),
+ OpenFileMappingW:sig(['u32','i32','ptr'],'ptr'),
+ MapViewOfFile:sig(['ptr','u32','u32','u32','u64'],'ptr'),
+ UnmapViewOfFile:sig(['ptr'],'i32'),CloseHandle:sig(['ptr'],'i32'),GetLastError:sig([],'u32'),
+});
+const entries=new Map();let next=-1;
+const MAX=256*1024*1024;
+const wide=s=>Buffer.from(s+'\0','utf16le');
+const fail=what=>Error(`${what}: Win32 error ${k.GetLastError()}`);
+function mapped(name,size,kind,create){
+ if(!/^Local\\buninu-wayland-[\da-f-]{36}$/.test(name)||!Number.isInteger(size)||size<1||size>MAX)throw Error('Invalid named mapping');
+ const handle=create?k.CreateFileMappingW(-1n,null,4,0,size,wide(name)):k.OpenFileMappingW(0xf001f,0,wide(name));
+ if(!handle)throw fail('File mapping');
+ if(create&&k.GetLastError()===183){k.CloseHandle(handle);throw Error('Mapping name collision')}
+ const address=k.MapViewOfFile(handle,0xf001f,0,0,size);
+ if(!address){const e=fail('MapViewOfFile');k.CloseHandle(handle);throw e}
+ return {name,size,kind,handle,address,bytes:Buffer.from(toArrayBuffer(address,0,size)),refs:0,forwarded:false};
+}
+function add(entry,writer=false){entry.refs++;const fd=next--;entries.set(fd,{entry,writer});return fd}
+export function createMapping(size,kind='pixels'){
+ const e=mapped('Local\\buninu-wayland-'+crypto.randomUUID(),size,kind,true);return add(e,kind==='pipe');
+}
+export function closeResource(fd){
+ if(fd>=0){closeSync(fd);return 0}
+ const item=entries.get(fd);if(!item)return 0;entries.delete(fd);
+ const e=item.entry;
+ if(item.writer&&!item.forwarded)Atomics.store(new Int32Array(e.bytes.buffer,e.bytes.byteOffset,2),1,1);
+ if(--e.refs===0){k.UnmapViewOfFile(e.address);k.CloseHandle(e.handle);e.bytes=null}
+ return 0;
+}
+export function sendResource(fd){
+ let item=entries.get(fd),temporary;
+ if(!item){const size=fstatSync(fd).size;if(size>MAX)throw Error('Resource exceeds limit');const data=Buffer.alloc(size);let at=0;while(at<size){const n=readSync(fd,data,at,size-at,at);if(!n)throw Error('Short resource file');at+=n}temporary=createMapping(Math.max(1,data.length),'bytes');item=entries.get(temporary);data.copy(item.entry.bytes)}
+ const retained=add(item.entry,false);
+ if(item.writer)item.forwarded=true;
+ const descriptor={name:item.entry.name,size:item.entry.size,kind:item.entry.kind,writer:item.writer};
+ if(temporary!==undefined)closeResource(temporary);
+ return {descriptor,release:()=>closeResource(retained)};
+}
+export function receiveResource(d){
+ if(!d||!['pixels','bytes','pipe'].includes(d.kind)||typeof d.writer!=='boolean'||(d.writer&&d.kind!=='pipe')||(d.kind==='pipe'&&d.size<9))throw Error('Invalid resource descriptor');
+ return add(mapped(d.name,d.size,d.kind,false),d.writer);
+}
+export function readResource(fd,buffer,offset=0,length=buffer.length-offset,position=null){
+ if(fd>=0)return readSync(fd,buffer,offset,length,position);
+ const item=entries.get(fd);if(!item)throw Error('Closed mapping');const e=item.entry;
+ if(e.kind==='pipe'){
+  const header=new Int32Array(e.bytes.buffer,e.bytes.byteOffset,2),available=Atomics.load(header,0),start=item.position??0;
+  if(available<start||available>e.size-8)throw Error('Invalid pipe length');
+  const n=Math.min(length,available-start);
+  if(!n&&!Atomics.load(header,1))throw Object.assign(Error('Pipe pending'),{code:'EAGAIN'});
+  e.bytes.copy(buffer,offset,8+start,8+start+n);item.position=start+n;return n;
+ }
+ const start=position??item.position??0,n=Math.max(0,Math.min(length,e.size-start));
+ e.bytes.copy(buffer,offset,start,start+n);if(position===null)item.position=start+n;return n;
+}
+export function writeResource(fd,buffer,offset=0,length=buffer.length-offset,position=null){
+ if(fd>=0)return writeSync(fd,buffer,offset,length,position);
+ const item=entries.get(fd);if(!item)throw Error('Closed mapping');const e=item.entry;
+ const start=e.kind==='pipe'?Atomics.load(new Int32Array(e.bytes.buffer,e.bytes.byteOffset,2),0):(position??item.position??0),header=e.kind==='pipe'?8:0;
+ if(start+length>e.size-header)throw Error('Mapping write exceeds capacity');
+ e.bytes.set(buffer.subarray(offset,offset+length),header+start);
+ if(header)Atomics.store(new Int32Array(e.bytes.buffer,e.bytes.byteOffset,2),0,start+length);else if(position===null)item.position=start+length;
+ return length;
+}
+let lastErrno=0;
+export const libc={
+ close:closeResource,createMapping,fcntl:()=>0,
+ pipe2(out){const fd=createMapping(1024*1024+8,'pipe'),e=entries.get(fd).entry;out[0]=add(e);out[1]=fd;return 0},
+ pread(fd,b,n,p){try{return readResource(fd,b,0,n,Number(p))}catch{lastErrno=5;return -1}},
+ read(fd,b,n){try{return readResource(fd,b,0,n)}catch(e){lastErrno=e.code==='EAGAIN'?11:5;return -1}},
+ write(fd,b,n){try{return writeResource(fd,b,0,n)}catch{lastErrno=5;return -1}},
+};
+export const errno=()=>lastErrno;