ntk 8.8.0 → 8.8.1

package/lib/gl.js

@@ -44,10 +44,13 @@ import { nodeRequire } from './builtin.js';
  *   Linux only, macOS needs no device node.
  * - `GL_REMOTE_DISPLAY` — a TCP or forwarded display; both flavors are
  *   local-only by construction.
- * - `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. Linux only —
- *   Apple-DRI passes no descriptors.
+ * - `GL_NO_FD_PASSING` — the display is local, but this connection cannot
+ *   send a descriptor over the socket. x11 has a transport for each runtime
+ *   it supports — `process.binding('pipe_wrap')` under Node, `bun:ffi`
+ *   calling `sendmsg(2)` under Bun since x11 4.1.0 — so what is left here is
+ *   an x11 below that under Bun, a runtime with neither path (Deno), or a
+ *   transport that would not initialise. Linux only — Apple-DRI passes no
+ *   descriptors.
  * - `GL_NO_DRI3` — the server has no DRI3/Present (Xvfb, Xephyr, XQuartz —
  *   though XQuartz has its own path, see `GL_NO_APPLEDRI`).
  * - `GL_NO_APPLEDRI` — macOS, and the server has no Apple-DRI extension:
@@ -418,17 +421,20 @@ export function glCapabilities(app) {
 
     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.
+      // descriptor along it. x11 carries one through Node's internal
+      // `process.binding('pipe_wrap')`, and under Bun through `bun:ffi`
+      // calling `sendmsg(2)` — the latter since x11 4.1.0, so an x11 below
+      // that under Bun lands here, as does a runtime with neither path and a
+      // transport that would not initialise. 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.'
+        `this connection cannot pass file descriptors over the X socket under ${runtimeName()}, and DRI3 works by passing one`,
+        'The connection is local; the descriptor transport is what is missing.\n' +
+          "x11 carries one through Node's process.binding('pipe_wrap') under Node, and\n" +
+          'through bun:ffi sendmsg(2) under Bun from x11 4.1.0 on. Under Bun on an older\n' +
+          'x11, `npm install x11@^4.1.0` is the whole fix. Otherwise leave glPolicy at\n' +
+          'its default and use indirect GLX, which needs no descriptor passing at all.'
       );
     }
 

package/lib/renderingcontext_2d.js

@@ -55,7 +55,9 @@ import {
   drawGlyphRuns,
   encodeGlyphItems,
   positionedRunsInk,
+  roundFrom,
   runId,
+  snapOrigin,
 } from "./text/glyphs.js";
 import { TextLayout } from "./text/layout.js";
 import { reorderRuns } from "./text/shape.js";
@@ -1365,6 +1367,12 @@ class RenderingContext2d {
    * whole pixel inside the surface, and the composite carries it to wherever
    * the text is. Glyph origins are rounded to whole pixels on the way to the
    * server anyway, so nothing is lost by it.
+   *
+   * Where it lands is rounded the way `positionGlyphs` rounds a glyph
+   * (`roundFrom`), so the shadow moves with its text: drawn whole pixels
+   * away, it lands exactly that many pixels away, and a scroll blit can copy
+   * it (issue #350). Rounded as one floating-point sum, an anchor on a half
+   * pixel went down at x 104 and up at x 152.
    */
   _shadowOfText(text, x, y) {
     const app = this.window.app;
@@ -1435,8 +1443,8 @@ class RenderingContext2d {
     if (!surface) return;
     this._paintShadow(
       surface,
-      Math.round(runX + this._shadowOffsetX) - originX,
-      Math.round(runY + this._shadowOffsetY) - originY,
+      roundFrom(runX, this._shadowOffsetX) - originX,
+      roundFrom(runY, this._shadowOffsetY) - originY,
     );
   }
 
@@ -1470,13 +1478,19 @@ class RenderingContext2d {
     // what the bitmap glyph path draws at anyway, and they keep the key
     // stable as the paragraph moves — `(x + a) - (x + b)` is not exactly
     // `a - b` in floating point, and an origin-dependent key would miss the
-    // cache on every scroll.
+    // cache on every scroll. Rounding alone does not absorb that where
+    // `a - b` is on a half pixel: the difference came to a hair under it at
+    // x 104 and exactly on it at x 152, and rounded two ways. So both
+    // origins are snapped first, as `positionGlyphs` snaps them (issue
+    // #350), and snapped origins subtract exactly.
     const ax = positioned[0].x;
     const ay = positioned[0].y;
+    const sx = snapOrigin(ax);
+    const sy = snapOrigin(ay);
     const local = positioned.map((p) => ({
       run: p.run,
-      x: Math.round(p.x - ax),
-      y: Math.round(p.y - ay),
+      x: Math.round(snapOrigin(p.x) - sx),
+      y: Math.round(snapOrigin(p.y) - sy),
       textRendering: p.textRendering,
     }));
     const key = `${local
@@ -1516,11 +1530,12 @@ class RenderingContext2d {
       return coverage;
     });
     if (surface) {
+      // anchored as fillText's shadow is, so it moves with the text
       const origin = surface._shadowOrigin;
       this._paintShadow(
         surface,
-        Math.round(ax + this._shadowOffsetX) - origin.x,
-        Math.round(ay + this._shadowOffsetY) - origin.y,
+        roundFrom(ax, this._shadowOffsetX) - origin.x,
+        roundFrom(ay, this._shadowOffsetY) - origin.y,
       );
       return;
     }

package/lib/text/glyphs.js

@@ -319,6 +319,11 @@ export function encodeGlyphItems(items, bits) {
   return { gsid, bits, elts };
 }
 
+// steps per pixel a text origin is snapped to before anything rounds against
+// it (see positionGlyphs and snapOrigin); a power of two, so the snap and the
+// split are exact
+const ORIGIN_STEPS = 256;
+
 /**
  * Compute device positions for shaped runs — the single source of truth for
  * where each glyph's origin lands, shared by the renderer and by tests that
@@ -328,20 +333,86 @@ export function encodeGlyphItems(items, bits) {
  * Font.shape()/shapeText() (already in visual order) and x/y is the run's
  * baseline origin in device space.
  *
+ * Placement is translation-invariant (issue #350): the same run drawn whole
+ * pixels away puts every glyph exactly that many pixels away, so a renderer
+ * that copies pixels it already drew — a scroll blit — matches a repaint
+ * byte for byte. The origin arrives as a whole-pixel position plus the
+ * layout's fractional offsets, summed in floating point, and the last bits
+ * of that sum depend on the whole part's magnitude: rounded as one number, a
+ * pen exactly on a half pixel went down at x 104 and up at x 152. So the
+ * origin is snapped to 1/256 px first and split into whole pixels and a
+ * fraction in [0, 1), and the pen walks from the fraction alone. Two origins
+ * whole pixels apart snap to fractions that are bit-identical, so every
+ * rounding after the snap sees the same numbers wherever the run is drawn.
+ * (Taking the fraction after the snap is what keeps it below 1: an origin a
+ * hair under a whole pixel and one exactly on it walk the same pen from 0.)
+ *
+ * The snap moves a glyph only where its pen lies within 1/512 px of a
+ * rounding boundary. The one knife-edge left is the snap's own — an origin
+ * within an ulp of an odd multiple of 1/512 px — a far narrower target than
+ * any pen along the run landing on a half pixel.
+ *
  * @returns {Array<{run, glyph, x, y}>} integer glyph-origin positions
  */
 export function positionGlyphs(positioned) {
   const out = [];
   for (const { run, x, y } of positioned) {
-    let cursor = x;
+    const sx = snapOrigin(x);
+    const sy = snapOrigin(y);
+    const ox = Math.floor(sx);
+    const oy = Math.floor(sy);
+    const fy = sy - oy;
+    let cursor = sx - ox;
     for (const g of run.glyphs) {
-      out.push({ run, glyph: g, x: Math.round(cursor + g.dx), y: Math.round(y - g.dy) });
+      out.push({
+        run,
+        glyph: g,
+        x: ox + Math.round(cursor + g.dx),
+        y: oy + Math.round(fy - g.dy)
+      });
       cursor += g.ax;
     }
   }
   return out;
 }
 
+/**
+ * A device-space origin snapped to 1/256 px, the way `positionGlyphs` takes
+ * a run's origin before anything rounds against it (issue #350).
+ *
+ * What comes back is an exact multiple of 1/256, so whole pixels split off
+ * it, and two snapped origins subtract, with no rounding at all. Origins
+ * whole pixels apart snap exactly that many pixels apart, bit for bit, even
+ * though the origins themselves — a whole-pixel position plus fractional
+ * layout offsets, summed in floating point — differ in their last bits.
+ * Anything else that rounds against a text origin needs the same: a text
+ * shadow's anchor, and the offsets between the runs its coverage holds.
+ *
+ * @param {number} v a device coordinate
+ * @returns {number} `v` to the nearest 1/256 px
+ */
+export function snapOrigin(v) {
+  return Math.round(v * ORIGIN_STEPS) / ORIGIN_STEPS;
+}
+
+/**
+ * `Math.round(origin + offset)`, rounded the way `positionGlyphs` rounds a
+ * glyph `offset` px from its run's origin: the snapped origin's whole
+ * pixels, plus its fraction and the offset rounded together. The one sum
+ * that rounds never sees the whole part, so moving the origin by whole
+ * pixels moves the answer by exactly those pixels, whatever the offset is.
+ * It is where a text shadow composites, `offset` being the shadow's own.
+ *
+ * @param {number} origin a device coordinate, a run's origin
+ * @param {number} offset px from it, along the same axis
+ * @returns {number} the whole pixel `origin + offset` lands on
+ */
+export function roundFrom(origin, offset) {
+  const s = snapOrigin(origin);
+  const whole = Math.floor(s);
+  return whole + Math.round(s - whole + offset);
+}
+
 /**
  * Ink extents of positioned runs, in whatever coordinates their origins are
  * given in — the union of every glyph's bounding box, laid out exactly as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.8.0",
+  "version": "8.8.1",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "linebreak": "^1.1.0",
     "parse-color": "^1.0.0",
     "pngjs": "^7.0.0",
-    "x11": "^4.0.1"
+    "x11": "^4.1.0"
   },
   "optionalDependencies": {
     "x11-dri": ">=0.5.0 <1"