three-text 0.2.19 → 0.3.0

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.2.19
+ * three-text v0.3.0
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -2379,231 +2379,50 @@ class Vec3 {
     }
 }
 
-// Generic LRU (Least Recently Used) cache with optional memory-based eviction
-class LRUCache {
-    constructor(options = {}) {
+// Map-based cache with no eviction policy
+class Cache {
+    constructor() {
         this.cache = new Map();
-        this.head = null;
-        this.tail = null;
-        this.stats = {
-            hits: 0,
-            misses: 0,
-            evictions: 0,
-            size: 0,
-            memoryUsage: 0
-        };
-        this.options = {
-            maxEntries: options.maxEntries ?? Infinity,
-            maxMemoryBytes: options.maxMemoryBytes ?? Infinity,
-            calculateSize: options.calculateSize ?? (() => 0),
-            onEvict: options.onEvict
-        };
     }
     get(key) {
-        const node = this.cache.get(key);
-        if (node) {
-            this.stats.hits++;
-            this.moveToHead(node);
-            return node.value;
-        }
-        else {
-            this.stats.misses++;
-            return undefined;
-        }
+        return this.cache.get(key);
     }
     has(key) {
         return this.cache.has(key);
     }
     set(key, value) {
-        // If key already exists, update it
-        const existingNode = this.cache.get(key);
-        if (existingNode) {
-            const oldSize = this.options.calculateSize(existingNode.value);
-            const newSize = this.options.calculateSize(value);
-            this.stats.memoryUsage = this.stats.memoryUsage - oldSize + newSize;
-            existingNode.value = value;
-            this.moveToHead(existingNode);
-            return;
-        }
-        const size = this.options.calculateSize(value);
-        // Evict entries if we exceed limits
-        this.evictIfNeeded(size);
-        // Create new node
-        const node = {
-            key,
-            value,
-            prev: null,
-            next: null
-        };
-        this.cache.set(key, node);
-        this.addToHead(node);
-        this.stats.size = this.cache.size;
-        this.stats.memoryUsage += size;
+        this.cache.set(key, value);
     }
     delete(key) {
-        const node = this.cache.get(key);
-        if (!node)
-            return false;
-        const size = this.options.calculateSize(node.value);
-        this.removeNode(node);
-        this.cache.delete(key);
-        this.stats.size = this.cache.size;
-        this.stats.memoryUsage -= size;
-        if (this.options.onEvict) {
-            this.options.onEvict(key, node.value);
-        }
-        return true;
+        return this.cache.delete(key);
     }
     clear() {
-        if (this.options.onEvict) {
-            for (const [key, node] of this.cache) {
-                this.options.onEvict(key, node.value);
-            }
-        }
         this.cache.clear();
-        this.head = null;
-        this.tail = null;
-        this.stats = {
-            hits: 0,
-            misses: 0,
-            evictions: 0,
-            size: 0,
-            memoryUsage: 0
-        };
-    }
-    getStats() {
-        const total = this.stats.hits + this.stats.misses;
-        const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
-        const memoryUsageMB = this.stats.memoryUsage / (1024 * 1024);
-        return {
-            ...this.stats,
-            hitRate,
-            memoryUsageMB
-        };
-    }
-    keys() {
-        const keys = [];
-        let current = this.head;
-        while (current) {
-            keys.push(current.key);
-            current = current.next;
-        }
-        return keys;
     }
     get size() {
         return this.cache.size;
     }
-    evictIfNeeded(requiredSize) {
-        // Evict by entry count
-        while (this.cache.size >= this.options.maxEntries && this.tail) {
-            this.evictTail();
-        }
-        // Evict by memory usage
-        if (this.options.maxMemoryBytes < Infinity) {
-            while (this.tail &&
-                this.stats.memoryUsage + requiredSize > this.options.maxMemoryBytes) {
-                this.evictTail();
-            }
-        }
-    }
-    evictTail() {
-        if (!this.tail)
-            return;
-        const nodeToRemove = this.tail;
-        const size = this.options.calculateSize(nodeToRemove.value);
-        this.removeTail();
-        this.cache.delete(nodeToRemove.key);
-        this.stats.size = this.cache.size;
-        this.stats.memoryUsage -= size;
-        this.stats.evictions++;
-        if (this.options.onEvict) {
-            this.options.onEvict(nodeToRemove.key, nodeToRemove.value);
-        }
-    }
-    addToHead(node) {
-        node.prev = null;
-        node.next = null;
-        if (!this.head) {
-            this.head = this.tail = node;
-        }
-        else {
-            node.next = this.head;
-            this.head.prev = node;
-            this.head = node;
-        }
-    }
-    removeNode(node) {
-        if (node.prev) {
-            node.prev.next = node.next;
-        }
-        else {
-            this.head = node.next;
-        }
-        if (node.next) {
-            node.next.prev = node.prev;
-        }
-        else {
-            this.tail = node.prev;
-        }
-    }
-    removeTail() {
-        if (this.tail) {
-            this.removeNode(this.tail);
-        }
+    keys() {
+        return Array.from(this.cache.keys());
     }
-    moveToHead(node) {
-        if (node === this.head)
-            return;
-        this.removeNode(node);
-        this.addToHead(node);
+    getStats() {
+        return {
+            size: this.cache.size
+        };
     }
 }
 
-const DEFAULT_CACHE_SIZE_MB = 250;
 function getGlyphCacheKey(fontId, glyphId, depth, removeOverlaps) {
     const roundedDepth = Math.round(depth * 1000) / 1000;
     return `${fontId}_${glyphId}_${roundedDepth}_${removeOverlaps}`;
 }
-function calculateGlyphMemoryUsage(glyph) {
-    let size = 0;
-    size += glyph.vertices.length * 4;
-    size += glyph.normals.length * 4;
-    size += glyph.indices.length * glyph.indices.BYTES_PER_ELEMENT;
-    size += 24; // 2 Vec3s
-    size += 256; // Object overhead
-    return size;
+const globalGlyphCache = new Cache();
+function createGlyphCache() {
+    return new Cache();
 }
-const globalGlyphCache = new LRUCache({
-    maxEntries: Infinity,
-    maxMemoryBytes: DEFAULT_CACHE_SIZE_MB * 1024 * 1024,
-    calculateSize: calculateGlyphMemoryUsage
-});
-function createGlyphCache(maxCacheSizeMB = DEFAULT_CACHE_SIZE_MB) {
-    return new LRUCache({
-        maxEntries: Infinity,
-        maxMemoryBytes: maxCacheSizeMB * 1024 * 1024,
-        calculateSize: calculateGlyphMemoryUsage
-    });
-}
-// Shared across builder instances: contour extraction, word clustering, boundary grouping
-const globalContourCache = new LRUCache({
-    maxEntries: 1000,
-    calculateSize: (contours) => {
-        let size = 0;
-        for (const path of contours.paths) {
-            size += path.points.length * 16; // Vec2 = 2 floats * 8 bytes
-        }
-        return size + 64; // bounds overhead
-    }
-});
-const globalWordCache = new LRUCache({
-    maxEntries: 1000,
-    calculateSize: calculateGlyphMemoryUsage
-});
-const globalClusteringCache = new LRUCache({
-    maxEntries: 2000,
-    calculateSize: () => 1
-});
+const globalContourCache = new Cache();
+const globalWordCache = new Cache();
+const globalClusteringCache = new Cache();
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -2938,47 +2757,79 @@ class Tessellator {
 
 class Extruder {
     constructor() { }
-    packEdge(a, b) {
-        const lo = a < b ? a : b;
-        const hi = a < b ? b : a;
-        return lo * 0x100000000 + hi;
-    }
     extrude(geometry, depth = 0, unitsPerEm) {
         const points = geometry.triangles.vertices;
         const triangleIndices = geometry.triangles.indices;
         const numPoints = points.length / 2;
-        // Count boundary edges for side walls (4 vertices + 6 indices per edge)
+        // Boundary edges are those that appear in exactly one triangle
         let boundaryEdges = [];
         if (depth !== 0) {
-            const counts = new Map();
-            const oriented = new Map();
-            for (let i = 0; i < triangleIndices.length; i += 3) {
+            // Pack edge pair into integer key: (min << 16) | max
+            // Fits glyph vertex indices comfortably, good hash distribution
+            const edgeMap = new Map();
+            const triLen = triangleIndices.length;
+            for (let i = 0; i < triLen; i += 3) {
                 const a = triangleIndices[i];
                 const b = triangleIndices[i + 1];
                 const c = triangleIndices[i + 2];
-                const k0 = this.packEdge(a, b);
-                const n0 = (counts.get(k0) ?? 0) + 1;
-                counts.set(k0, n0);
-                if (n0 === 1)
-                    oriented.set(k0, [a, b]);
-                const k1 = this.packEdge(b, c);
-                const n1 = (counts.get(k1) ?? 0) + 1;
-                counts.set(k1, n1);
-                if (n1 === 1)
-                    oriented.set(k1, [b, c]);
-                const k2 = this.packEdge(c, a);
-                const n2 = (counts.get(k2) ?? 0) + 1;
-                counts.set(k2, n2);
-                if (n2 === 1)
-                    oriented.set(k2, [c, a]);
+                let key, v0, v1;
+                if (a < b) {
+                    key = (a << 16) | b;
+                    v0 = a;
+                    v1 = b;
+                }
+                else {
+                    key = (b << 16) | a;
+                    v0 = a;
+                    v1 = b;
+                }
+                let data = edgeMap.get(key);
+                if (data) {
+                    data[2]++;
+                }
+                else {
+                    edgeMap.set(key, [v0, v1, 1]);
+                }
+                if (b < c) {
+                    key = (b << 16) | c;
+                    v0 = b;
+                    v1 = c;
+                }
+                else {
+                    key = (c << 16) | b;
+                    v0 = b;
+                    v1 = c;
+                }
+                data = edgeMap.get(key);
+                if (data) {
+                    data[2]++;
+                }
+                else {
+                    edgeMap.set(key, [v0, v1, 1]);
+                }
+                if (c < a) {
+                    key = (c << 16) | a;
+                    v0 = c;
+                    v1 = a;
+                }
+                else {
+                    key = (a << 16) | c;
+                    v0 = c;
+                    v1 = a;
+                }
+                data = edgeMap.get(key);
+                if (data) {
+                    data[2]++;
+                }
+                else {
+                    edgeMap.set(key, [v0, v1, 1]);
+                }
             }
             boundaryEdges = [];
-            for (const [key, count] of counts) {
-                if (count !== 1)
-                    continue;
-                const edge = oriented.get(key);
-                if (edge)
-                    boundaryEdges.push(edge);
+            for (const [v0, v1, count] of edgeMap.values()) {
+                if (count === 1) {
+                    boundaryEdges.push([v0, v1]);
+                }
             }
         }
         const sideEdgeCount = depth === 0 ? 0 : boundaryEdges.length;
@@ -2992,7 +2843,6 @@ class Extruder {
             : triangleIndices.length * 2 + sideEdgeCount * 6;
         const indices = new Uint32Array(indexCount);
         if (depth === 0) {
-            // Single-sided flat geometry at z=0
             let vPos = 0;
             for (let i = 0; i < points.length; i += 2) {
                 vertices[vPos] = points[i];
@@ -3003,16 +2853,11 @@ class Extruder {
                 normals[vPos + 2] = 1;
                 vPos += 3;
             }
-            // libtess outputs CCW, use as-is for +Z facing geometry
-            for (let i = 0; i < triangleIndices.length; i++) {
-                indices[i] = triangleIndices[i];
-            }
+            indices.set(triangleIndices);
             return { vertices, normals, indices };
         }
-        // Extruded geometry: front at z=0, back at z=depth
         const minBackOffset = unitsPerEm * 0.000025;
         const backZ = depth <= minBackOffset ? minBackOffset : depth;
-        // Generate both caps in one pass
         for (let p = 0, vi = 0; p < points.length; p += 2, vi++) {
             const x = points[p];
             const y = points[p + 1];
@@ -3033,41 +2878,39 @@ class Extruder {
             normals[baseD + 1] = 0;
             normals[baseD + 2] = 1;
         }
-        // libtess outputs CCW triangles (viewed from +Z)
-        // Z=0 cap faces -Z, reverse winding
-        for (let i = 0; i < triangleIndices.length; i++) {
-            indices[i] = triangleIndices[triangleIndices.length - 1 - i];
+        // Front cap faces -Z, reverse winding from libtess CCW output
+        const triLen = triangleIndices.length;
+        for (let i = 0; i < triLen; i++) {
+            indices[i] = triangleIndices[triLen - 1 - i];
         }
-        // Z=depth cap faces +Z, use original winding
-        for (let i = 0; i < triangleIndices.length; i++) {
-            indices[triangleIndices.length + i] = triangleIndices[i] + numPoints;
+        // Back cap faces +Z, use original winding
+        for (let i = 0; i < triLen; i++) {
+            indices[triLen + i] = triangleIndices[i] + numPoints;
         }
-        // Side walls
         let nextVertex = numPoints * 2;
-        let idxPos = triangleIndices.length * 2;
-        for (let e = 0; e < boundaryEdges.length; e++) {
-            const [u, v] = boundaryEdges[e];
-            const u2 = u * 2;
-            const v2 = v * 2;
+        let idxPos = triLen * 2;
+        const numEdges = boundaryEdges.length;
+        for (let e = 0; e < numEdges; e++) {
+            const edge = boundaryEdges[e];
+            const u = edge[0];
+            const v = edge[1];
+            const u2 = u << 1;
+            const v2 = v << 1;
             const p0x = points[u2];
             const p0y = points[u2 + 1];
             const p1x = points[v2];
             const p1y = points[v2 + 1];
-            // Perpendicular normal for this wall segment
-            // Uses the edge direction from the cap triangulation so winding does not depend on contour direction
             const ex = p1x - p0x;
             const ey = p1y - p0y;
             const lenSq = ex * ex + ey * ey;
             let nx = 0;
             let ny = 0;
-            if (lenSq > 0) {
+            if (lenSq > 1e-10) {
                 const invLen = 1 / Math.sqrt(lenSq);
                 nx = ey * invLen;
                 ny = -ex * invLen;
             }
-            const baseVertex = nextVertex;
-            const base = baseVertex * 3;
-            // Wall quad: front edge at z=0, back edge at z=depth
+            const base = nextVertex * 3;
             vertices[base] = p0x;
             vertices[base + 1] = p0y;
             vertices[base + 2] = 0;
@@ -3080,7 +2923,6 @@ class Extruder {
             vertices[base + 9] = p1x;
             vertices[base + 10] = p1y;
             vertices[base + 11] = backZ;
-            // Wall normals point perpendicular to edge
             normals[base] = nx;
             normals[base + 1] = ny;
             normals[base + 2] = 0;
@@ -3093,13 +2935,14 @@ class Extruder {
             normals[base + 9] = nx;
             normals[base + 10] = ny;
             normals[base + 11] = 0;
-            // Two triangles per wall segment
-            indices[idxPos++] = baseVertex;
-            indices[idxPos++] = baseVertex + 1;
-            indices[idxPos++] = baseVertex + 2;
-            indices[idxPos++] = baseVertex + 1;
-            indices[idxPos++] = baseVertex + 3;
-            indices[idxPos++] = baseVertex + 2;
+            const baseVertex = nextVertex;
+            indices[idxPos] = baseVertex;
+            indices[idxPos + 1] = baseVertex + 1;
+            indices[idxPos + 2] = baseVertex + 2;
+            indices[idxPos + 3] = baseVertex + 1;
+            indices[idxPos + 4] = baseVertex + 3;
+            indices[idxPos + 5] = baseVertex + 2;
+            idxPos += 6;
             nextVertex += 4;
         }
         return { vertices, normals, indices };
@@ -4116,7 +3959,7 @@ class GlyphGeometryBuilder {
         ].join('|');
     }
     // Build instanced geometry from glyph contours
-    buildInstancedGeometry(clustersByLine, depth, removeOverlaps, isCFF, separateGlyphs = false, coloredTextIndices) {
+    buildInstancedGeometry(clustersByLine, depth, removeOverlaps, isCFF, scale, separateGlyphs = false, coloredTextIndices) {
         if (isLogEnabled) {
             let wordCount = 0;
             for (let i = 0; i < clustersByLine.length; i++) {
@@ -4294,9 +4137,9 @@ class GlyphGeometryBuilder {
             const py = task.py;
             const pz = task.pz;
             for (let j = 0; j < v.length; j += 3) {
-                vertexArray[vertexPos++] = v[j] + px;
-                vertexArray[vertexPos++] = v[j + 1] + py;
-                vertexArray[vertexPos++] = v[j + 2] + pz;
+                vertexArray[vertexPos++] = (v[j] + px) * scale;
+                vertexArray[vertexPos++] = (v[j + 1] + py) * scale;
+                vertexArray[vertexPos++] = (v[j + 2] + pz) * scale;
             }
             normalArray.set(n, normalPos);
             normalPos += n.length;
@@ -4306,6 +4149,20 @@ class GlyphGeometryBuilder {
             }
         }
         perfLogger.end('GlyphGeometryBuilder.buildInstancedGeometry');
+        planeBounds.min.x *= scale;
+        planeBounds.min.y *= scale;
+        planeBounds.min.z *= scale;
+        planeBounds.max.x *= scale;
+        planeBounds.max.y *= scale;
+        planeBounds.max.z *= scale;
+        for (let i = 0; i < glyphInfos.length; i++) {
+            glyphInfos[i].bounds.min.x *= scale;
+            glyphInfos[i].bounds.min.y *= scale;
+            glyphInfos[i].bounds.min.z *= scale;
+            glyphInfos[i].bounds.max.x *= scale;
+            glyphInfos[i].bounds.max.y *= scale;
+            glyphInfos[i].bounds.max.z *= scale;
+        }
         return {
             vertices: vertexArray,
             normals: normalArray,
@@ -4317,7 +4174,6 @@ class GlyphGeometryBuilder {
     getClusterKey(glyphs, depth, removeOverlaps) {
         if (glyphs.length === 0)
             return '';
-        // Normalize positions relative to the first glyph in the cluster
         const refX = glyphs[0].x ?? 0;
         const refY = glyphs[0].y ?? 0;
         const parts = glyphs.map((g) => {
@@ -5372,6 +5228,7 @@ class TextRangeQuery {
 }
 
 const DEFAULT_MAX_TEXT_LENGTH = 100000;
+const DEFAULT_FONT_SIZE = 72;
 class Text {
     static { this.patternCache = new Map(); }
     static { this.hbInitPromise = null; }
@@ -5445,7 +5302,7 @@ class Text {
             return {
                 ...newResult,
                 getLoadedFont: () => text.getLoadedFont(),
-                getCacheStatistics: () => text.getCacheStatistics(),
+                getCacheSize: () => text.getCacheSize(),
                 clearCache: () => text.clearCache(),
                 measureTextWidth: (textString, letterSpacing) => text.measureTextWidth(textString, letterSpacing),
                 update
@@ -5454,7 +5311,7 @@ class Text {
         return {
             ...result,
             getLoadedFont: () => text.getLoadedFont(),
-            getCacheStatistics: () => text.getCacheStatistics(),
+            getCacheSize: () => text.getCacheSize(),
             clearCache: () => text.clearCache(),
             measureTextWidth: (textString, letterSpacing) => text.measureTextWidth(textString, letterSpacing),
             update
@@ -5586,7 +5443,7 @@ class Text {
     async createGeometry(options) {
         perfLogger.start('Text.createGeometry', {
             textLength: options.text.length,
-            size: options.size || 72,
+            size: options.size || DEFAULT_FONT_SIZE,
             hasLayout: !!options.layout,
             mode: 'cached'
         });
@@ -5600,7 +5457,7 @@ class Text {
             this.updateFontVariations(options);
             if (!this.geometryBuilder) {
                 const cache = options.maxCacheSizeMB
-                    ? createGlyphCache(options.maxCacheSizeMB)
+                    ? createGlyphCache()
                     : globalGlyphCache;
                 this.geometryBuilder = new GlyphGeometryBuilder(cache, this.loadedFont);
                 this.geometryBuilder.setFontId(this.currentFontId);
@@ -5646,10 +5503,9 @@ class Text {
                     }
                 }
             }
-            const shapedResult = this.geometryBuilder.buildInstancedGeometry(clustersByLine, layoutData.depth, shouldRemoveOverlaps, this.loadedFont.metrics.isCFF, options.separateGlyphsWithAttributes || false, coloredTextIndices);
-            const cacheStats = this.geometryBuilder.getCacheStats();
-            const result = this.finalizeGeometry(shapedResult.vertices, shapedResult.normals, shapedResult.indices, shapedResult.glyphInfos, shapedResult.planeBounds, options, cacheStats, options.text);
-            if (options.separateGlyphsWithAttributes) {
+            const shapedResult = this.geometryBuilder.buildInstancedGeometry(clustersByLine, layoutData.depth, shouldRemoveOverlaps, this.loadedFont.metrics.isCFF, layoutData.pixelsPerFontUnit, options.perGlyphAttributes ?? false, coloredTextIndices);
+            const result = this.finalizeGeometry(shapedResult.vertices, shapedResult.normals, shapedResult.indices, shapedResult.glyphInfos, shapedResult.planeBounds, options, options.text);
+            if (options.perGlyphAttributes) {
                 const glyphAttrs = this.createGlyphAttributes(result.vertices.length / 3, result.glyphs);
                 result.glyphAttributes = glyphAttrs;
             }
@@ -5716,16 +5572,16 @@ class Text {
         if (!this.loadedFont) {
             throw new Error('Font not loaded. Use Text.create() with a font option');
         }
-        const { text, size = 72, depth = 0, lineHeight = 1.0, letterSpacing = 0, layout = {} } = options;
+        const { text, size = DEFAULT_FONT_SIZE, depth = 0, lineHeight = 1.0, letterSpacing = 0, layout = {} } = options;
         const { width, direction = 'ltr', align = direction === 'rtl' ? 'right' : 'left', respectExistingBreaks = true, hyphenate = true, language = 'en-us', tolerance = DEFAULT_TOLERANCE, pretolerance = DEFAULT_PRETOLERANCE, emergencyStretch = DEFAULT_EMERGENCY_STRETCH, autoEmergencyStretch, hyphenationPatterns, lefthyphenmin, righthyphenmin, linepenalty, adjdemerits, hyphenpenalty, exhyphenpenalty, doublehyphendemerits, looseness, disableShortLineDetection, shortLineThreshold } = layout;
+        const fontUnitsPerPixel = this.loadedFont.upem / size;
         let widthInFontUnits;
         if (width !== undefined) {
-            widthInFontUnits = width * (this.loadedFont.upem / size);
+            widthInFontUnits = width * fontUnitsPerPixel;
         }
         // Keep depth behavior consistent with Extruder: extremely small non-zero depths
-        // are clamped to a minimum back offset so the back face is not coplanar.
-        const depthScale = this.loadedFont.upem / size;
-        const rawDepthInFontUnits = depth * depthScale;
+        // are clamped to a minimum back offset to prevent Z fighting
+        const rawDepthInFontUnits = depth * fontUnitsPerPixel;
         const minExtrudeDepth = this.loadedFont.upem * 0.000025;
         const depthInFontUnits = rawDepthInFontUnits <= 0
             ? 0
@@ -5768,7 +5624,8 @@ class Text {
             align,
             direction,
             depth: depthInFontUnits,
-            size
+            size,
+            pixelsPerFontUnit: 1 / fontUnitsPerPixel
         };
     }
     applyColorSystem(vertices, glyphInfoArray, color, originalText) {
@@ -5864,8 +5721,8 @@ class Text {
         }
         return { colors, coloredRanges };
     }
-    finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, cacheStats, originalText) {
-        const { layout = {}, size = 72 } = options;
+    finalizeGeometry(vertices, normals, indices, glyphInfoArray, planeBounds, options, originalText) {
+        const { layout = {} } = options;
         const { width, align = layout.direction === 'rtl' ? 'right' : 'left' } = layout;
         if (!this.textLayout) {
             this.textLayout = new TextLayout(this.loadedFont);
@@ -5878,37 +5735,14 @@ class Text {
         const offset = alignmentResult.offset;
         planeBounds.min.x = alignmentResult.adjustedBounds.min.x;
         planeBounds.max.x = alignmentResult.adjustedBounds.max.x;
-        const finalScale = size / this.loadedFont.upem;
-        const offsetScaled = offset * finalScale;
-        // Scale vertices only (normals are unit vectors, don't scale)
-        if (offsetScaled === 0) {
-            for (let i = 0; i < vertices.length; i++) {
-                vertices[i] *= finalScale;
-            }
-        }
-        else {
+        if (offset !== 0) {
             for (let i = 0; i < vertices.length; i += 3) {
-                vertices[i] = vertices[i] * finalScale + offsetScaled;
-                vertices[i + 1] *= finalScale;
-                vertices[i + 2] *= finalScale;
-            }
-        }
-        planeBounds.min.x *= finalScale;
-        planeBounds.min.y *= finalScale;
-        planeBounds.min.z *= finalScale;
-        planeBounds.max.x *= finalScale;
-        planeBounds.max.y *= finalScale;
-        planeBounds.max.z *= finalScale;
-        for (let i = 0; i < glyphInfoArray.length; i++) {
-            const glyphInfo = glyphInfoArray[i];
-            glyphInfo.bounds.min.x =
-                glyphInfo.bounds.min.x * finalScale + offsetScaled;
-            glyphInfo.bounds.min.y *= finalScale;
-            glyphInfo.bounds.min.z *= finalScale;
-            glyphInfo.bounds.max.x =
-                glyphInfo.bounds.max.x * finalScale + offsetScaled;
-            glyphInfo.bounds.max.y *= finalScale;
-            glyphInfo.bounds.max.z *= finalScale;
+                vertices[i] += offset;
+            }
+            for (let i = 0; i < glyphInfoArray.length; i++) {
+                glyphInfoArray[i].bounds.min.x += offset;
+                glyphInfoArray[i].bounds.max.x += offset;
+            }
         }
         let colors;
         let coloredRanges;
@@ -5933,8 +5767,7 @@ class Text {
                 verticesGenerated,
                 pointsRemovedByVisvalingam: optimizationStats.pointsRemovedByVisvalingam,
                 pointsRemovedByColinear: optimizationStats.pointsRemovedByColinear,
-                originalPointCount: optimizationStats.originalPointCount,
-                ...(cacheStats || {})
+                originalPointCount: optimizationStats.originalPointCount
             },
             query: (options) => {
                 if (!originalText) {
@@ -5985,11 +5818,11 @@ class Text {
         }
         return TextMeasurer.measureTextWidth(this.loadedFont, text, letterSpacing);
     }
-    getCacheStatistics() {
+    getCacheSize() {
         if (this.geometryBuilder) {
-            return this.geometryBuilder.getCacheStats();
+            return this.geometryBuilder.getCacheStats().size;
         }
-        return null;
+        return 0;
     }
     clearCache() {
         if (this.geometryBuilder) {
@@ -6000,25 +5833,45 @@ class Text {
         const glyphCenters = new Float32Array(vertexCount * 3);
         const glyphIndices = new Float32Array(vertexCount);
         const glyphLineIndices = new Float32Array(vertexCount);
-        glyphs.forEach((glyph, index) => {
+        const glyphProgress = new Float32Array(vertexCount);
+        const glyphBaselineY = new Float32Array(vertexCount);
+        let minX = Infinity;
+        let maxX = -Infinity;
+        for (let i = 0; i < glyphs.length; i++) {
+            const cx = (glyphs[i].bounds.min.x + glyphs[i].bounds.max.x) / 2;
+            if (cx < minX)
+                minX = cx;
+            if (cx > maxX)
+                maxX = cx;
+        }
+        const range = maxX - minX;
+        for (let index = 0; index < glyphs.length; index++) {
+            const glyph = glyphs[index];
             const centerX = (glyph.bounds.min.x + glyph.bounds.max.x) / 2;
             const centerY = (glyph.bounds.min.y + glyph.bounds.max.y) / 2;
             const centerZ = (glyph.bounds.min.z + glyph.bounds.max.z) / 2;
-            for (let i = 0; i < glyph.vertexCount; i++) {
-                const vertexIndex = glyph.vertexStart + i;
-                if (vertexIndex < vertexCount) {
-                    glyphCenters[vertexIndex * 3] = centerX;
-                    glyphCenters[vertexIndex * 3 + 1] = centerY;
-                    glyphCenters[vertexIndex * 3 + 2] = centerZ;
-                    glyphIndices[vertexIndex] = index;
-                    glyphLineIndices[vertexIndex] = glyph.lineIndex;
-                }
+            const baselineY = glyph.bounds.min.y;
+            const progress = range > 0 ? (centerX - minX) / range : 0;
+            const start = glyph.vertexStart;
+            const end = Math.min(start + glyph.vertexCount, vertexCount);
+            if (end <= start)
+                continue;
+            glyphIndices.fill(index, start, end);
+            glyphLineIndices.fill(glyph.lineIndex, start, end);
+            glyphProgress.fill(progress, start, end);
+            glyphBaselineY.fill(baselineY, start, end);
+            for (let v = start * 3; v < end * 3; v += 3) {
+                glyphCenters[v] = centerX;
+                glyphCenters[v + 1] = centerY;
+                glyphCenters[v + 2] = centerZ;
             }
-        });
+        }
         return {
             glyphCenter: glyphCenters,
             glyphIndex: glyphIndices,
-            glyphLineIndex: glyphLineIndices
+            glyphLineIndex: glyphLineIndices,
+            glyphProgress,
+            glyphBaselineY
         };
     }
     resetHelpers() {