flea-qml 0.0.0-stage → 0.1.0

package/src/wayland/protocols/wlr-data-control-unstable-v1.xml

@@ -0,0 +1,278 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_data_control_unstable_v1">
+  <copyright>
+    Copyright © 2018 Simon Ser
+    Copyright © 2019 Ivan Molodetskikh
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <description summary="control data devices">
+    This protocol allows a privileged client to control data devices. In
+    particular, the client will be able to manage the current selection and take
+    the role of a clipboard manager.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwlr_data_control_manager_v1" version="2">
+    <description summary="manager to control data devices">
+      This interface is a manager that allows creating per-seat data device
+      controls.
+    </description>
+
+    <request name="create_data_source">
+      <description summary="create a new data source">
+        Create a new data source.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_data_control_source_v1"
+        summary="data source to create"/>
+    </request>
+
+    <request name="get_data_device">
+      <description summary="get a data device for a seat">
+        Create a data device that can be used to manage a seat's selection.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_data_control_device_v1"/>
+      <arg name="seat" type="object" interface="wl_seat"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their
+        appropriate destroy request has been called.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_data_control_device_v1" version="2">
+    <description summary="manage a data device for a seat">
+      This interface allows a client to manage a seat's selection.
+
+      When the seat is destroyed, this object becomes inert.
+    </description>
+
+    <request name="set_selection">
+      <description summary="copy data to the selection">
+        This request asks the compositor to set the selection to the data from
+        the source on behalf of the client.
+
+        The given source may not be used in any further set_selection or
+        set_primary_selection requests. Attempting to use a previously used
+        source is a protocol error.
+
+        To unset the selection, set the source to NULL.
+      </description>
+      <arg name="source" type="object" interface="zwlr_data_control_source_v1"
+        allow-null="true"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy this data device">
+        Destroys the data device object.
+      </description>
+    </request>
+
+    <event name="data_offer">
+      <description summary="introduce a new wlr_data_control_offer">
+        The data_offer event introduces a new wlr_data_control_offer object,
+        which will subsequently be used in either the
+        wlr_data_control_device.selection event (for the regular clipboard
+        selections) or the wlr_data_control_device.primary_selection event (for
+        the primary clipboard selections). Immediately following the
+        wlr_data_control_device.data_offer event, the new data_offer object
+        will send out wlr_data_control_offer.offer events to describe the MIME
+        types it offers.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_data_control_offer_v1"/>
+    </event>
+
+    <event name="selection">
+      <description summary="advertise new selection">
+        The selection event is sent out to notify the client of a new
+        wlr_data_control_offer for the selection for this device. The
+        wlr_data_control_device.data_offer and the wlr_data_control_offer.offer
+        events are sent out immediately before this event to introduce the data
+        offer object. The selection event is sent to a client when a new
+        selection is set. The wlr_data_control_offer is valid until a new
+        wlr_data_control_offer or NULL is received. The client must destroy the
+        previous selection wlr_data_control_offer, if any, upon receiving this
+        event.
+
+        The first selection event is sent upon binding the
+        wlr_data_control_device object.
+      </description>
+      <arg name="id" type="object" interface="zwlr_data_control_offer_v1"
+        allow-null="true"/>
+    </event>
+
+    <event name="finished">
+      <description summary="this data control is no longer valid">
+        This data control object is no longer valid and should be destroyed by
+        the client.
+      </description>
+    </event>
+
+    <!-- Version 2 additions -->
+
+    <event name="primary_selection" since="2">
+      <description summary="advertise new primary selection">
+        The primary_selection event is sent out to notify the client of a new
+        wlr_data_control_offer for the primary selection for this device. The
+        wlr_data_control_device.data_offer and the wlr_data_control_offer.offer
+        events are sent out immediately before this event to introduce the data
+        offer object. The primary_selection event is sent to a client when a
+        new primary selection is set. The wlr_data_control_offer is valid until
+        a new wlr_data_control_offer or NULL is received. The client must
+        destroy the previous primary selection wlr_data_control_offer, if any,
+        upon receiving this event.
+
+        If the compositor supports primary selection, the first
+        primary_selection event is sent upon binding the
+        wlr_data_control_device object.
+      </description>
+      <arg name="id" type="object" interface="zwlr_data_control_offer_v1"
+        allow-null="true"/>
+    </event>
+
+    <request name="set_primary_selection" since="2">
+      <description summary="copy data to the primary selection">
+        This request asks the compositor to set the primary selection to the
+        data from the source on behalf of the client.
+
+        The given source may not be used in any further set_selection or
+        set_primary_selection requests. Attempting to use a previously used
+        source is a protocol error.
+
+        To unset the primary selection, set the source to NULL.
+
+        The compositor will ignore this request if it does not support primary
+        selection.
+      </description>
+      <arg name="source" type="object" interface="zwlr_data_control_source_v1"
+        allow-null="true"/>
+    </request>
+
+    <enum name="error" since="2">
+      <entry name="used_source" value="1"
+        summary="source given to set_selection or set_primary_selection was already used before"/>
+    </enum>
+  </interface>
+
+  <interface name="zwlr_data_control_source_v1" version="1">
+    <description summary="offer to transfer data">
+      The wlr_data_control_source object is the source side of a
+      wlr_data_control_offer. It is created by the source client in a data
+      transfer and provides a way to describe the offered data and a way to
+      respond to requests to transfer the data.
+    </description>
+
+    <enum name="error">
+      <entry name="invalid_offer" value="1"
+        summary="offer sent after wlr_data_control_device.set_selection"/>
+    </enum>
+
+    <request name="offer">
+      <description summary="add an offered MIME type">
+        This request adds a MIME type to the set of MIME types advertised to
+        targets. Can be called several times to offer multiple types.
+
+        Calling this after wlr_data_control_device.set_selection is a protocol
+        error.
+      </description>
+      <arg name="mime_type" type="string"
+        summary="MIME type offered by the data source"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy this source">
+        Destroys the data source object.
+      </description>
+    </request>
+
+    <event name="send">
+      <description summary="send the data">
+        Request for data from the client. Send the data as the specified MIME
+        type over the passed file descriptor, then close it.
+      </description>
+      <arg name="mime_type" type="string" summary="MIME type for the data"/>
+      <arg name="fd" type="fd" summary="file descriptor for the data"/>
+    </event>
+
+    <event name="cancelled">
+      <description summary="selection was cancelled">
+        This data source is no longer valid. The data source has been replaced
+        by another data source.
+
+        The client should clean up and destroy this data source.
+      </description>
+    </event>
+  </interface>
+
+  <interface name="zwlr_data_control_offer_v1" version="1">
+    <description summary="offer to transfer data">
+      A wlr_data_control_offer represents a piece of data offered for transfer
+      by another client (the source client). The offer describes the different
+      MIME types that the data can be converted to and provides the mechanism
+      for transferring the data directly from the source client.
+    </description>
+
+    <request name="receive">
+      <description summary="request that the data is transferred">
+        To transfer the offered data, the client issues this request and
+        indicates the MIME type it wants to receive. The transfer happens
+        through the passed file descriptor (typically created with the pipe
+        system call). The source client writes the data in the MIME type
+        representation requested and then closes the file descriptor.
+
+        The receiving client reads from the read end of the pipe until EOF and
+        then closes its end, at which point the transfer is complete.
+
+        This request may happen multiple times for different MIME types.
+      </description>
+      <arg name="mime_type" type="string"
+        summary="MIME type desired by receiver"/>
+      <arg name="fd" type="fd" summary="file descriptor for data transfer"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy this offer">
+        Destroys the data offer object.
+      </description>
+    </request>
+
+    <event name="offer">
+      <description summary="advertise offered MIME type">
+        Sent immediately after creating the wlr_data_control_offer object.
+        One event per offered MIME type.
+      </description>
+      <arg name="mime_type" type="string" summary="offered MIME type"/>
+    </event>
+  </interface>
+</protocol>

package/src/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/src/wayland/socket-discovery.js

@@ -0,0 +1,26 @@
+import {join,isAbsolute} from 'node:path';
+import {tmpdir} from 'node:os';
+export function socketCandidates(path,{env=process.env,temp=tmpdir()}={}){
+ if(path!==undefined&&path!==null)return [path];
+ const directory=env.XDG_RUNTIME_DIR||env.TMPDIR||temp;
+ const displays=env.WAYLAND_DISPLAY?[env.WAYLAND_DISPLAY]:['wayland-buninu','wayland-0'];
+ return displays.map(display=>isAbsolute(display)?display:join(directory,display));
+}
+export async function discoverSocket(connect,path,options={}){
+ const failures=[];
+ for(const candidate of socketCandidates(path,options)){
+  let connection;
+  try{
+   connection=connect(candidate);
+   await connection.ready;
+   if(connection.closed)throw connection.error??Error('Connection closed');
+   return connection;
+  }catch(error){connection?.close();failures.push(`  ${candidate}: ${error.message}`)}
+ }
+ const env=options.env??process.env;
+ throw Error(`Unable to connect to a Wayland compositor. Tried:\n${failures.join('\n')}\n`
+  +`Set XDG_RUNTIME_DIR to the compositor's socket directory and WAYLAND_DISPLAY to its socket name.\n`
+  +`Example: export XDG_RUNTIME_DIR=/path/to/runtime; export WAYLAND_DISPLAY=wayland-buninu\n`
+  +(process.platform==='win32'?`PowerShell: $env:XDG_RUNTIME_DIR='C:\\path\\to\\runtime'; $env:WAYLAND_DISPLAY='wayland-buninu'\n`:'')
+  +(env.WAYLAND_DISPLAY?'WAYLAND_DISPLAY was explicitly set; other socket names were not tried.':''));
+}

package/src/wayland/transport-posix.js

@@ -0,0 +1,120 @@
+// Adapted from buninu-browser frontends/wayland@7fe8cc3, itself from buninu-land/lib/transport.js (MIT, Dr. John).
+// 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/src/wayland/transport-win32.js

@@ -0,0 +1,11 @@
+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);
+ c.ready=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()}}}).then(()=>c).catch(e=>{c.error=e;c.close();throw e});
+ // Callers may queue requests before initialize awaits the connection.
+ c.ready.catch(()=>{});
+ return c;
+}

package/src/wayland/transport.js

@@ -0,0 +1,3 @@
+// 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/src/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;

package/src/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()}
+ }
+}