three-text 0.6.0 → 0.6.2

package/README.md

@@ -19,8 +19,6 @@ High fidelity 3D text rendering and layout for the web
 
 The library has a framework-agnostic core with lightweight adapters for [Three.js](https://threejs.org), [React Three Fiber](https://docs.pmnd.rs/react-three-fiber), [p5.js](https://p5js.org), [WebGL](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API), and [WebGPU](https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API)
 
-Under the hood, three-text relies on a core of [harfbuzzjs](https://github.com/harfbuzz/harfbuzzjs) (based on [HarfBuzz](https://github.com/harfbuzz/harfbuzz) by Behdad Esfahbod et al) for text shaping, [Knuth-Plass](http://www.eprg.org/G53DOC/pdfs/knuth-plass-breaking.pdf) line breaking (with [SILE](https://github.com/sile-typesetter/sile/blob/master/core/break.lua) and LuaTex being the closest modern references), [Liang](https://tug.org/docs/liang/liang-thesis.pdf) hyphenation and the [TeX hyphenation patterns](https://github.com/hyphenation/tex-hyphen), and [woff-lib](https://github.com/countertype/woff-lib) for optional WOFF2 support. The mesh text pipeline uses [libtess-ts](https://github.com/countertype/libtess-ts) (a port of the [GLU tessellator](https://www.songho.ca/opengl/gl_tessellation.html) by Eric Veach) for removing overlaps and triangulation, adaptive curve polygonization from Maxim Shemanarev's [Anti-Grain Geometry](https://web.archive.org/web/20060128212843/http://www.antigrain.com/research/adaptive_bezier/index.html), and [Visvalingam-Whyatt](https://hull-repository.worktribe.com/preview/376364/000870493786962263.pdf) [line simplification](https://bost.ocks.org/mike/simplify/). The vector pipeline uses [Slug](https://github.com/EricLengyel/Slug) by Eric Lengyel for resolution-independent curve rendering
-
 ## Table of contents
 
 - [Overview](#overview)
@@ -41,6 +39,7 @@ Under the hood, three-text relies on a core of [harfbuzzjs](https://github.com/h
 - [Browser compatibility](#browser-compatibility)
 - [Testing](#testing)
 - [Build system](#build-system)
+- [Entry points](#entry-points)
 - [Build outputs](#build-outputs)
 - [Acknowledgements](#acknowledgements)
 - [License](#license)
@@ -60,34 +59,14 @@ npm install three
 
 ## Architecture
 
-three-text has a framework-agnostic core that processes fonts and generates geometry data. Lightweight adapters convert this data to framework-specific formats:
-
-- **`three-text`** - Three.js adapter (default export, returns `BufferGeometry`)
-- **`three-text/mesh`** - Same as above (explicit alias)
-- **`three-text/mesh/react`** - React Three Fiber component for extruded mesh text
-- **`three-text/three`** - Deprecated, use `three-text/mesh`
-- **`three-text/three/react`** - Deprecated, use `three-text/mesh/react`
-- **`three-text/mesh/webgl`** - WebGL mesh buffer utility
-- **`three-text/mesh/webgpu`** - WebGPU mesh buffer utility
-- **`three-text/mesh/p5`** - p5.js adapter
-- **`three-text/core`** - Framework-agnostic core (returns raw arrays)
-- **`three-text/vector`** - Vector rendering (Slug per-fragment curve evaluation), `Text.create()` returns a `THREE.Group`
-- **`three-text/vector/react`** - React Three Fiber component for vector text
-- **`three-text/vector/core`** - Framework-agnostic vector core (returns raw `SlugGPUData`, no Three.js dependency)
-- **`three-text/vector/webgl`** - Raw WebGL2 vector renderer (no Three.js dependency)
-- **`three-text/vector/webgpu`** - Raw WebGPU vector renderer (no Three.js dependency)
-- **`three-text/webgl`** - Deprecated, use `three-text/mesh/webgl`
-- **`three-text/webgpu`** - Deprecated, use `three-text/mesh/webgpu`
-- **`three-text/p5`** - Deprecated, use `three-text/mesh/p5`
-
-Most users will just `import { Text } from 'three-text'` for Three.js projects with mesh, or `import { Text } from 'three-text/vector'` for vector text
+three-text has a framework-agnostic core that processes fonts and generates geometry data. Lightweight adapters convert this data to framework-specific formats. Most users will just `import { Text } from 'three-text'` for Three.js projects with mesh, or `import { Text } from 'three-text/vector'` for vector text. See [Entry points](#entry-points) for the full list of adapters
 
 ### Mesh vs vector
 
 The library offers two rendering modes that share the same core (HarfBuzz shaping, Knuth-Plass justification, glyph caching):
 
 - **Mesh** (`three-text` (default) / `three-text/mesh`): triangulated geometry you can extrude, light, and shade. Use for 3D text, text in a scene graph, or anywhere you need depth
-- **Vector** (`three-text/vector`): resolution-independent rendering on the GPU via per-fragment curve evaluation. No tessellation, no stencil buffer. Use for text that needs to stay sharp at arbitrary zoom
+- **Vector** (`three-text/vector`): resolution-independent rendering on the GPU via per-fragment curve evaluation. Use for flat text that needs to stay sharp at arbitrary zoom
 
 Both can be used in the same project from separate entry points
 
@@ -483,6 +462,8 @@ Existing solutions take different approaches:
 
 three-text produces actual geometry from font files, sharper at close distances than bitmap approaches, with control over typesetting and paragraph justification via TeX-based parameters
 
+Under the hood, three-text relies on a core of [harfbuzzjs](https://github.com/harfbuzz/harfbuzzjs) (based on [HarfBuzz](https://github.com/harfbuzz/harfbuzz) by Behdad Esfahbod et al) for text shaping, [Knuth-Plass](http://www.eprg.org/G53DOC/pdfs/knuth-plass-breaking.pdf) line breaking (with [SILE](https://github.com/sile-typesetter/sile/blob/master/core/break.lua) and LuaTex being the closest modern references), [Liang](https://tug.org/docs/liang/liang-thesis.pdf) hyphenation and the [TeX hyphenation patterns](https://github.com/hyphenation/tex-hyphen), and [woff-lib](https://github.com/countertype/woff-lib) for optional WOFF2 support. The mesh text pipeline uses [libtess-ts](https://github.com/countertype/libtess-ts) (a port of the [GLU tessellator](https://www.songho.ca/opengl/gl_tessellation.html) by Eric Veach) for removing overlaps and triangulation, adaptive curve polygonization from Maxim Shemanarev's [Anti-Grain Geometry](https://web.archive.org/web/20060128212843/http://www.antigrain.com/research/adaptive_bezier/index.html), and [Visvalingam-Whyatt](https://hull-repository.worktribe.com/preview/376364/000870493786962263.pdf) [line simplification](https://bost.ocks.org/mike/simplify/). The vector pipeline uses [Slug](https://github.com/EricLengyel/Slug) by Eric Lengyel for resolution-independent curve rendering
+
 ### Why Slug
 
 The vector path uses the Slug algorithm by Eric Lengyel. Each glyph is a single quad; the fragment shader evaluates curve coverage analytically to compute a winding number. Because it operates on winding rather than geometry, it naturally handles the self-intersecting contours that variable fonts produce when axes like weight push outlines into each other
@@ -1256,6 +1237,22 @@ git submodule update --init --recursive
 
 The script then processes the TeX hyphenation data into optimized trie structures. The process is slow for the complete set of languages (~1 minute on an M2 Max), so using `--languages` for development is recommended
 
+## Entry points
+
+- **`three-text`** - Three.js adapter (default export, returns mesh `BufferGeometry`)
+- **`three-text/mesh`** - Same as above (explicit alias)
+- **`three-text/mesh/react`** - React Three Fiber component for extruded mesh text
+- **`three-text/three/react`** - Deprecated, use `three-text/mesh/react`
+- **`three-text/mesh/webgl`** - WebGL mesh buffer utility
+- **`three-text/mesh/webgpu`** - WebGPU mesh buffer utility
+- **`three-text/mesh/p5`** - p5.js adapter
+- **`three-text/core`** - Framework-agnostic core (returns raw arrays)
+- **`three-text/vector`** - Vector rendering (Slug per-fragment curve evaluation), `Text.create()` returns a `THREE.Group`
+- **`three-text/vector/react`** - React Three Fiber component for vector text
+- **`three-text/vector/core`** - Framework-agnostic vector core (returns raw `SlugGPUData`, no Three.js dependency)
+- **`three-text/vector/webgl`** - Raw WebGL2 vector renderer (no Three.js dependency)
+- **`three-text/vector/webgpu`** - Raw WebGPU vector renderer (no Three.js dependency)
+
 ## Build outputs
 
 The build generates multiple module formats for core and all adapters:
@@ -1289,4 +1286,4 @@ The build generates multiple module formats for core and all adapters:
 
 `three-text` was written by Jeremy Tribby ([@jpt](https://github.com/jpt)) and is licensed under the MIT License. See the [LICENSE](LICENSE) file for details
 
-This software includes code from third-party libraries under compatible permissive licenses. For full license details, see the [LICENSE_THIRD_PARTY](LICENSE_THIRD_PARTY) file
+This software includes code from third-party libraries under compatible permissive licenses. For full license details, see the [LICENSE_THIRD_PARTY](LICENSE_THIRD_PARTY) file

package/dist/index.cjs

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.0
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.0
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.min.cjs

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.0
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.min.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.0
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.umd.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.0
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/index.umd.min.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.6.0
+ * three-text v0.6.2
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */

package/dist/vector/core/index.cjs

@@ -258,7 +258,6 @@ class GlyphOutlineCollector {
 // GPU-ready packed textures + vertex attribute buffers
 const TEX_WIDTH = 4096;
 const LOG_TEX_WIDTH = 12;
-// Float/Uint32 reinterpretation helpers
 const _f32 = new Float32Array(1);
 const _u32 = new Uint32Array(_f32.buffer);
 function uintAsFloat(u) {
@@ -270,9 +269,7 @@ function uintAsFloat(u) {
 function packSlugData(shapes, options) {
     const bandCount = options?.bandCount ?? 16;
     const evenOdd = options?.evenOdd ?? false;
-    // Pack all curves into curveTexture
     const allCurves = [];
-    // Estimate max texels needed
     let totalCurves = 0;
     for (const shape of shapes) {
         totalCurves += shape.curves.length;
@@ -283,28 +280,33 @@ function packSlugData(shapes, options) {
     let curveY = 0;
     for (const shape of shapes) {
         const entries = [];
+        const [ox, oy] = shape.bounds;
         for (const curve of shape.curves) {
-            // Don't let a curve span across row boundary (needs 2 consecutive texels)
             if (curveX >= TEX_WIDTH - 1) {
                 curveX = 0;
                 curveY++;
             }
+            // Glyph-local space (relative to bounds min) keeps renderCoord
+            // subtraction near zero, preserving float32 precision in the solver
+            const lp1x = curve.p1[0] - ox, lp1y = curve.p1[1] - oy;
+            const lp2x = curve.p2[0] - ox, lp2y = curve.p2[1] - oy;
+            const lp3x = curve.p3[0] - ox, lp3y = curve.p3[1] - oy;
             const base = (curveY * TEX_WIDTH + curveX) * 4;
-            curveData[base + 0] = curve.p1[0];
-            curveData[base + 1] = curve.p1[1];
-            curveData[base + 2] = curve.p2[0];
-            curveData[base + 3] = curve.p2[1];
+            curveData[base + 0] = lp1x;
+            curveData[base + 1] = lp1y;
+            curveData[base + 2] = lp2x;
+            curveData[base + 3] = lp2y;
             const base2 = base + 4;
-            curveData[base2 + 0] = curve.p3[0];
-            curveData[base2 + 1] = curve.p3[1];
-            const minX = Math.min(curve.p1[0], curve.p2[0], curve.p3[0]);
-            const minY = Math.min(curve.p1[1], curve.p2[1], curve.p3[1]);
-            const maxX = Math.max(curve.p1[0], curve.p2[0], curve.p3[0]);
-            const maxY = Math.max(curve.p1[1], curve.p2[1], curve.p3[1]);
+            curveData[base2 + 0] = lp3x;
+            curveData[base2 + 1] = lp3y;
+            const minX = Math.min(lp1x, lp2x, lp3x);
+            const minY = Math.min(lp1y, lp2y, lp3y);
+            const maxX = Math.max(lp1x, lp2x, lp3x);
+            const maxY = Math.max(lp1y, lp2y, lp3y);
             entries.push({
-                p1x: curve.p1[0], p1y: curve.p1[1],
-                p2x: curve.p2[0], p2y: curve.p2[1],
-                p3x: curve.p3[0], p3y: curve.p3[1],
+                p1x: lp1x, p1y: lp1y,
+                p2x: lp2x, p2y: lp2y,
+                p3x: lp3x, p3y: lp3y,
                 minX, minY, maxX, maxY,
                 curveTexX: curveX,
                 curveTexY: curveY
@@ -314,12 +316,10 @@ function packSlugData(shapes, options) {
         allCurves.push(entries);
     }
     const actualCurveTexHeight = curveY + 1;
-    // Build band data for each shape and pack into bandTexture
-    // Layout per shape in bandTexture (relative to glyphLoc):
-    //   [0 .. hBandMax]                          : h-band headers
-    //   [hBandMax+1 .. hBandMax+1+vBandMax]      : v-band headers
-    //   [hBandMax+vBandMax+2 .. ]                : curve index lists
-    // First pass: compute total band texels needed
+    // Band texture layout per shape (relative to glyphLoc):
+    //   [0 .. hBandMax]                     h-band headers
+    //   [hBandMax+1 .. hBandMax+1+vBandMax] v-band headers
+    //   [hBandMax+vBandMax+2 .. ]           curve index lists
     const shapeBandData = [];
     let totalBandTexels = 0;
     for (let si = 0; si < shapes.length; si++) {
@@ -339,21 +339,19 @@ function packSlugData(shapes, options) {
         const vBandCount = Math.min(bandCount, 255);
         const bandMaxY = hBandCount - 1;
         const bandMaxX = vBandCount - 1;
-        // Build horizontal bands (partition y-axis)
+        // Horizontal bands (partition y-axis)
         const hBands = [];
         const hLists = [];
         const bandH = h / hBandCount;
         for (let bi = 0; bi < hBandCount; bi++) {
-            const bandMinY = bMinY + bi * bandH;
+            const bandMinY = bi * bandH;
             const bandMaxYCoord = bandMinY + bandH;
-            // Collect curves whose y-range overlaps this band
             const list = [];
             for (const c of curves) {
                 if (c.maxY >= bandMinY && c.minY <= bandMaxYCoord) {
                     list.push({ curve: c, sortKey: c.maxX });
                 }
             }
-            // Sort by descending max-x for early exit
             list.sort((a, b) => b.sortKey - a.sortKey);
             const flatList = [];
             for (const item of list) {
@@ -362,12 +360,12 @@ function packSlugData(shapes, options) {
             hBands.push({ curveCount: list.length, listOffset: 0 });
             hLists.push(flatList);
         }
-        // Build vertical bands (partition x-axis)
+        // Vertical bands (partition x-axis)
         const vBands = [];
         const vLists = [];
         const bandW = w / vBandCount;
         for (let bi = 0; bi < vBandCount; bi++) {
-            const bandMinX = bMinX + bi * bandW;
+            const bandMinX = bi * bandW;
             const bandMaxXCoord = bandMinX + bandW;
             const list = [];
             for (const c of curves) {
@@ -375,7 +373,6 @@ function packSlugData(shapes, options) {
                     list.push({ curve: c, sortKey: c.maxY });
                 }
             }
-            // Sort by descending max-y for early exit
             list.sort((a, b) => b.sortKey - a.sortKey);
             const flatList = [];
             for (const item of list) {
@@ -384,7 +381,6 @@ function packSlugData(shapes, options) {
             vBands.push({ curveCount: list.length, listOffset: 0 });
             vLists.push(flatList);
         }
-        // Total texels for this shape: band headers + curve lists
         const headerTexels = hBandCount + vBandCount;
         let listTexels = 0;
         for (const l of hLists)
@@ -398,10 +394,8 @@ function packSlugData(shapes, options) {
         });
         totalBandTexels += total;
     }
-    // Allocate bandTexture (extra rows for row-alignment padding of curve lists)
     const bandTexHeight = Math.max(1, Math.ceil(totalBandTexels / TEX_WIDTH) + shapes.length * 2);
     const bandData = new Uint32Array(TEX_WIDTH * bandTexHeight * 4);
-    // Pack band data per shape
     let bandX = 0;
     let bandY = 0;
     const glyphLocs = [];
@@ -411,11 +405,8 @@ function packSlugData(shapes, options) {
             glyphLocs.push({ x: 0, y: 0 });
             continue;
         }
-        // Ensure glyph data doesn't start too close to row end
-        // (need at least headerTexels contiguous... actually wrapping is handled by CalcBandLoc)
-        // But the initial band header reads don't use CalcBandLoc, so glyphLoc.x + bandMax.y + 1 + bandMaxX
-        // must be reachable. CalcBandLoc handles wrapping for curve lists.
-        // To be safe, start each glyph at the beginning of a row if remaining space is tight.
+        // Band headers are read without CalcBandLoc wrapping, so all
+        // headers for a glyph must fit within a single texture row
         const minContiguous = sd.hBands.length + sd.vBands.length;
         if (bandX + minContiguous > TEX_WIDTH) {
             bandX = 0;
@@ -424,11 +415,8 @@ function packSlugData(shapes, options) {
         const glyphLocX = bandX;
         const glyphLocY = bandY;
         glyphLocs.push({ x: glyphLocX, y: glyphLocY });
-        // Curve lists start after all headers
         let listStartOffset = sd.hBands.length + sd.vBands.length;
-        // The shader reads curve list entries at (hbandLoc.x + curveIndex, hbandLoc.y)
-        // with NO row wrapping. Each list must fit entirely within a single texture row.
-        // Pad the offset to the next row start when a list would cross a row boundary.
+        // Curve lists aren't row-wrapped by the shader, so pad to avoid crossing
         const ensureListFits = (listLen) => {
             if (listLen === 0)
                 return;
@@ -437,21 +425,18 @@ function packSlugData(shapes, options) {
                 listStartOffset += (TEX_WIDTH - startX);
             }
         };
-        // Assign list offsets for h-bands
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const listLen = sd.hLists[bi].length / 2;
             ensureListFits(listLen);
             sd.hBands[bi].listOffset = listStartOffset;
             listStartOffset += listLen;
         }
-        // Assign list offsets for v-bands
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const listLen = sd.vLists[bi].length / 2;
             ensureListFits(listLen);
             sd.vBands[bi].listOffset = listStartOffset;
             listStartOffset += listLen;
         }
-        // Write h-band headers
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const tx = glyphLocX + bi;
             const ty = glyphLocY;
@@ -461,7 +446,6 @@ function packSlugData(shapes, options) {
             bandData[idx + 2] = 0;
             bandData[idx + 3] = 0;
         }
-        // Write v-band headers (after h-bands)
         const vBandStart = glyphLocX + sd.hBands.length;
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const tx = vBandStart + bi;
@@ -472,9 +456,7 @@ function packSlugData(shapes, options) {
             bandData[idx + 2] = 0;
             bandData[idx + 3] = 0;
         }
-        // Write curve lists using CalcBandLoc-style wrapping
         const texWidthMask = (1 << LOG_TEX_WIDTH) - 1;
-        // Write h-band curve lists
         for (let bi = 0; bi < sd.hBands.length; bi++) {
             const list = sd.hLists[bi];
             const baseOffset = sd.hBands[bi].listOffset;
@@ -483,13 +465,12 @@ function packSlugData(shapes, options) {
                 const by = glyphLocY + (bx >> LOG_TEX_WIDTH);
                 bx &= texWidthMask;
                 const idx = (by * TEX_WIDTH + bx) * 4;
-                bandData[idx + 0] = list[ci]; // curveTexX
-                bandData[idx + 1] = list[ci + 1]; // curveTexY
+                bandData[idx + 0] = list[ci];
+                bandData[idx + 1] = list[ci + 1];
                 bandData[idx + 2] = 0;
                 bandData[idx + 3] = 0;
             }
         }
-        // Write v-band curve lists
         for (let bi = 0; bi < sd.vBands.length; bi++) {
             const list = sd.vLists[bi];
             const baseOffset = sd.vBands[bi].listOffset;
@@ -504,24 +485,20 @@ function packSlugData(shapes, options) {
                 bandData[idx + 3] = 0;
             }
         }
-        // Advance band cursor past this shape's data
         let endBx = glyphLocX + listStartOffset;
         bandY = glyphLocY + (endBx >> LOG_TEX_WIDTH);
         bandX = endBx & texWidthMask;
     }
     const actualBandTexHeight = bandY + 1;
-    // Build vertex attributes
-    // 5 attribs x 4 floats x 4 vertices per shape = 80 floats per shape
     const FLOATS_PER_VERTEX = 20; // 5 attribs * 4 components
     const VERTS_PER_SHAPE = 4;
     const vertices = new Float32Array(shapes.length * VERTS_PER_SHAPE * FLOATS_PER_VERTEX);
     const indices = new Uint16Array(shapes.length * 6);
-    // Corner normals (outward-pointing, un-normalized; SlugDilate normalizes)
     const cornerNormals = [
-        [-1, -1], // bottom-left
-        [1, -1], // bottom-right
-        [1, 1], // top-right
-        [-1, 1], // top-left
+        [-1, -1],
+        [1, -1],
+        [1, 1],
+        [-1, 1],
     ];
     for (let si = 0; si < shapes.length; si++) {
         const shape = shapes[si];
@@ -530,32 +507,25 @@ function packSlugData(shapes, options) {
         const [bMinX, bMinY, bMaxX, bMaxY] = shape.bounds;
         const w = bMaxX - bMinX;
         const h = bMaxY - bMinY;
-        // Corner positions in object-space
         const corners = [
             [bMinX, bMinY],
             [bMaxX, bMinY],
             [bMaxX, bMaxY],
             [bMinX, bMaxY],
         ];
-        // Em-space sample coords at corners (same as object-space for 1:1 mapping)
         const emCorners = [
-            [bMinX, bMinY],
-            [bMaxX, bMinY],
-            [bMaxX, bMaxY],
-            [bMinX, bMaxY],
+            [0, 0],
+            [w, 0],
+            [w, h],
+            [0, h],
         ];
-        // Pack tex.z: glyph location in band texture
         const texZ = uintAsFloat((glyph.x & 0xFFFF) | ((glyph.y & 0xFFFF) << 16));
-        // Pack tex.w: band max + flags
         let texWBits = (sd.bandMaxX & 0xFF) | ((sd.bandMaxY & 0xFF) << 16);
         if (evenOdd)
             texWBits |= 0x10000000; // E flag at bit 28
         const texW = uintAsFloat(texWBits);
-        // Band transform: scale and offset to map em-coords to band indices
         const bandScaleX = w > 0 ? sd.vBands.length / w : 0;
         const bandScaleY = h > 0 ? sd.hBands.length / h : 0;
-        const bandOffsetX = -bMinX * bandScaleX;
-        const bandOffsetY = -bMinY * bandScaleY;
         for (let vi = 0; vi < 4; vi++) {
             const base = (si * 4 + vi) * FLOATS_PER_VERTEX;
             // pos: .xy = position, .zw = normal
@@ -568,23 +538,22 @@ function packSlugData(shapes, options) {
             vertices[base + 5] = emCorners[vi][1];
             vertices[base + 6] = texZ;
             vertices[base + 7] = texW;
-            // jac: identity Jacobian (em-space = object-space)
+            // jac: identity (em-space is a translation of object-space)
             vertices[base + 8] = 1.0;
             vertices[base + 9] = 0.0;
             vertices[base + 10] = 0.0;
             vertices[base + 11] = 1.0;
-            // bnd: band scale and offset
+            // bnd: band scale (offset zero in glyph-local space)
             vertices[base + 12] = bandScaleX;
             vertices[base + 13] = bandScaleY;
-            vertices[base + 14] = bandOffsetX;
-            vertices[base + 15] = bandOffsetY;
-            // col: white with full alpha (caller overrides via uniform or attribute)
+            vertices[base + 14] = 0;
+            vertices[base + 15] = 0;
+            // col
             vertices[base + 16] = 1.0;
             vertices[base + 17] = 1.0;
             vertices[base + 18] = 1.0;
             vertices[base + 19] = 1.0;
         }
-        // Indices: two triangles per quad
         const vBase = si * 4;
         const iBase = si * 6;
         indices[iBase + 0] = vBase + 0;
@@ -793,7 +762,6 @@ function computePlaneBounds(glyphInfos) {
     }
     return { min: { x: minX, y: minY, z: 0 }, max: { x: maxX, y: maxY, z: 0 } };
 }
-// Public API
 function buildVectorResult(layoutHandle, ctx, options) {
     const scale = layoutHandle.layoutData.pixelsPerFontUnit;
     let cachedQuery = null;