ntk 7.3.1 → 7.3.3

package/lib/gl.js

@@ -32,8 +32,11 @@ import { nodeRequire } from './builtin.js';
  * - `GL_NO_DRIVER` — the addon loaded but the GPU libraries it needs are
  *   missing (`libgbm`, `libEGL`, `libGLESv2`), or this is not Linux.
  * - `GL_NO_DEVICE` — no readable DRM render node (`/dev/dri/renderD*`).
- * - `GL_REMOTE_DISPLAY` — the connection cannot carry descriptors: a TCP or
- *   forwarded display, so there is no way to hand the server a buffer.
+ * - `GL_REMOTE_DISPLAY` — a TCP or forwarded display, so there is no local
+ *   socket to hand the server a buffer down.
+ * - `GL_NO_FD_PASSING` — the display is local, but this JavaScript runtime
+ *   cannot send a descriptor over the socket. Bun is the case in the field;
+ *   x11 does it through a Node internal Bun does not implement.
  * - `GL_NO_DRI3` — the server has no DRI3/Present (Xvfb, Xephyr, XQuartz).
  * - `GL_IMPORT_FAILED` — the server refused the buffer; usually client and
  *   server on different DRM devices.
@@ -45,6 +48,7 @@ export const GLError = {
   NO_DRIVER: 'GL_NO_DRIVER',
   NO_DEVICE: 'GL_NO_DEVICE',
   REMOTE_DISPLAY: 'GL_REMOTE_DISPLAY',
+  NO_FD_PASSING: 'GL_NO_FD_PASSING',
   NO_DRI3: 'GL_NO_DRI3',
   IMPORT_FAILED: 'GL_IMPORT_FAILED',
   CONTEXT_FAILED: 'GL_CONTEXT_FAILED'
@@ -235,6 +239,14 @@ export function canPassDescriptors(display) {
 
 const displayName = () => globalThis.process?.env?.DISPLAY || 'the X server';
 
+/** What is running this, for an error that is about the runtime. */
+const runtimeName = () => {
+  const versions = globalThis.process?.versions;
+  if (versions?.bun) return `Bun (${versions.bun})`;
+  if (versions?.deno) return `Deno (${versions.deno})`;
+  return versions?.node ? `Node (${versions.node})` : 'JavaScript runtime';
+};
+
 const requireExt = (X, name) =>
   new Promise((resolve) => X.require(name, (err, ext) => resolve(err ? null : ext)));
 
@@ -266,14 +278,29 @@ export function glCapabilities(app) {
     if (policy.mode === 'off') {
       return fail(GLError.DISABLED, "glPolicy is 'off', so no GL context will be created");
     }
-    if (!canPassDescriptors(app.display)) {
+    if (!app.display.isLocalSocket) {
       return fail(
         GLError.REMOTE_DISPLAY,
-        'this X connection is not a local socket that can pass descriptors, and DRI3 works by passing one',
+        'this X connection is not a local socket, and DRI3 works by passing a descriptor down one',
         'Direct rendering is local-only by construction. Over a network, indirect GLX is\n' +
           'the backend that can work at all — leave glPolicy at its default.'
       );
     }
+    if (!canPassDescriptors(app.display)) {
+      // The socket is local; what is missing is the ability to send a
+      // descriptor along it. x11 does that through Node's internal
+      // `process.binding('pipe_wrap')`, so a runtime that does not implement
+      // it lands here — Bun, today. Saying "not a local socket" would send
+      // the reader off to check their DISPLAY, which is fine.
+      return fail(
+        GLError.NO_FD_PASSING,
+        `this ${runtimeName()} cannot pass file descriptors over the X socket, and DRI3 works by passing one`,
+        'The connection is local; the runtime is what cannot carry the descriptor.\n' +
+          "x11 sends one through Node's process.binding('pipe_wrap'), which Bun does\n" +
+          'not implement. Run under Node for direct rendering, or leave glPolicy at its\n' +
+          'default and use indirect GLX, which needs no descriptor passing at all.'
+      );
+    }
 
     const client = probeDirect(policy);
     if (!client.ok) return fail(client.code, client.message, client.hint);
@@ -291,9 +318,10 @@ export function glCapabilities(app) {
     }
     if (!DRI3.fdCapable) {
       return fail(
-        GLError.REMOTE_DISPLAY,
+        GLError.NO_FD_PASSING,
         'the x11 client cannot send descriptors on this connection (DRI3.fdCapable is false)',
-        'x11 builds an fd-capable socket for local displays unless `shm: false` was passed\nto createClient.'
+        'x11 builds an fd-capable socket for local displays unless `shm: false` was passed\n' +
+          'to createClient, and needs a runtime that can pass descriptors — see above.'
       );
     }
 

package/lib/renderingcontext_2d.js

@@ -2965,15 +2965,21 @@ class RenderingContext2d {
           rect.h,
         ]);
       }
+      // The scratch mask is surface-sized and surface-aligned — the coverage
+      // went into it at (dx, dy) — and so is a gradient source, so both are
+      // sampled at the destination offset. Reading either from (0, 0) draws a
+      // dw x dh window out of the wrong part of a full-surface picture: for
+      // the mask that is the region just cleared to zero, so nothing paints at
+      // all unless dx and dy are both zero.
       R.Composite(
         op,
         this._backgroundPicture.id,
         this.fillMask.id,
         this.picture.id,
-        0,
-        0,
-        0,
-        0,
+        dx,
+        dy,
+        dx,
+        dy,
         dx,
         dy,
         dw,
@@ -2996,13 +3002,16 @@ class RenderingContext2d {
           rect.h,
         ]);
       }
+      // the source is a 1x1 repeating solid (offset irrelevant) or the fill
+      // picture, which for a gradient is surface-aligned: same offset as the
+      // destination, exactly as in _fillPolys
       R.Composite(
         op,
         this._coverageSource().id,
         picture.id,
         this.picture.id,
-        0,
-        0,
+        dx,
+        dy,
         mx,
         my,
         dx,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "7.3.1",
+  "version": "7.3.3",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",