three-text 0.2.12 → 0.2.14

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.2.12
+ * three-text v0.2.14
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -50,7 +50,9 @@
             if (!isLogEnabled)
                 return;
             const startTime = performance.now();
-            this.activeTimers.set(name, startTime);
+            // Generate unique key for nested timing support
+            const timerKey = `${name}_${startTime}`;
+            this.activeTimers.set(timerKey, startTime);
             this.metrics.push({
                 name,
                 startTime,
@@ -62,17 +64,26 @@
             if (!isLogEnabled)
                 return null;
             const endTime = performance.now();
-            const startTime = this.activeTimers.get(name);
-            if (startTime === undefined) {
+            // Find the most recent matching timer by scanning backwards
+            let timerKey;
+            let startTime;
+            for (const [key, time] of Array.from(this.activeTimers.entries()).reverse()) {
+                if (key.startsWith(`${name}_`)) {
+                    timerKey = key;
+                    startTime = time;
+                    break;
+                }
+            }
+            if (startTime === undefined || !timerKey) {
                 logger.warn(`Performance timer "${name}" was not started`);
                 return null;
             }
             const duration = endTime - startTime;
-            this.activeTimers.delete(name);
+            this.activeTimers.delete(timerKey);
             // Find the metric in reverse order (most recent first)
             for (let i = this.metrics.length - 1; i >= 0; i--) {
                 const metric = this.metrics[i];
-                if (metric.name === name && !metric.endTime) {
+                if (metric.name === name && metric.startTime === startTime && !metric.endTime) {
                     metric.endTime = endTime;
                     metric.duration = duration;
                     break;
@@ -715,7 +726,7 @@
                 align: options.align || 'left',
                 hyphenate: options.hyphenate || false
             });
-            const { text, width, align = 'left', direction = 'ltr', hyphenate = false, language = 'en-us', respectExistingBreaks = true, measureText, hyphenationPatterns, unitsPerEm, tolerance = DEFAULT_TOLERANCE, pretolerance = DEFAULT_PRETOLERANCE, emergencyStretch = DEFAULT_EMERGENCY_STRETCH, autoEmergencyStretch, lefthyphenmin = DEFAULT_LEFT_HYPHEN_MIN, righthyphenmin = DEFAULT_RIGHT_HYPHEN_MIN, linepenalty = DEFAULT_LINE_PENALTY, adjdemerits = DEFAULT_FITNESS_DIFF_DEMERITS, hyphenpenalty = DEFAULT_HYPHEN_PENALTY, exhyphenpenalty = DEFAULT_EX_HYPHEN_PENALTY, doublehyphendemerits = DEFAULT_DOUBLE_HYPHEN_DEMERITS, looseness = 0, disableShortLineDetection = false, shortLineThreshold = SHORT_LINE_WIDTH_THRESHOLD } = options;
+            const { text, width, align = 'left', direction = 'ltr', hyphenate = false, language = 'en-us', respectExistingBreaks = true, measureText, hyphenationPatterns, unitsPerEm, letterSpacing = 0, tolerance = DEFAULT_TOLERANCE, pretolerance = DEFAULT_PRETOLERANCE, emergencyStretch = DEFAULT_EMERGENCY_STRETCH, autoEmergencyStretch, lefthyphenmin = DEFAULT_LEFT_HYPHEN_MIN, righthyphenmin = DEFAULT_RIGHT_HYPHEN_MIN, linepenalty = DEFAULT_LINE_PENALTY, adjdemerits = DEFAULT_FITNESS_DIFF_DEMERITS, hyphenpenalty = DEFAULT_HYPHEN_PENALTY, exhyphenpenalty = DEFAULT_EX_HYPHEN_PENALTY, doublehyphendemerits = DEFAULT_DOUBLE_HYPHEN_DEMERITS, looseness = 0, disableShortLineDetection = false, shortLineThreshold = SHORT_LINE_WIDTH_THRESHOLD } = options;
             // Handle multiple paragraphs by processing each independently
             if (respectExistingBreaks && text.includes('\n')) {
                 const paragraphs = text.split('\n');
@@ -777,7 +788,11 @@
                 hyphenPenalty: hyphenpenalty,
                 exHyphenPenalty: exhyphenpenalty,
                 currentAlign: align,
-                unitsPerEm
+                unitsPerEm,
+                // measureText() includes trailing letter spacing after the final glyph of a token.
+                // Shaping applies letter spacing only between glyphs, so we subtract one
+                // trailing letterSpacingFU per line segment (see computeAdjustmentRatio/createLines).
+                letterSpacingFU: unitsPerEm ? letterSpacing * unitsPerEm : 0
             };
             if (!width || width === Infinity) {
                 const measuredWidth = measureText(text);
@@ -1085,7 +1100,7 @@
                 }
             }
         }
-        static computeAdjustmentRatio(items, lineStart, lineEnd, _lineNumber, lineWidth, cumulativeWidths, _context) {
+        static computeAdjustmentRatio(items, lineStart, lineEnd, _lineNumber, lineWidth, cumulativeWidths, context) {
             let totalWidth = 0;
             let totalStretch = 0;
             let totalShrink = 0;
@@ -1128,6 +1143,12 @@
                         ? items[lineEnd].width
                         : items[lineEnd].preBreakWidth;
             }
+            // Correct for trailing letter spacing at the end of the line segment.
+            // Our token measurement includes letter spacing after the final glyph;
+            // shaping does not add letter spacing after the final glyph in a line.
+            if (context?.letterSpacingFU && totalWidth !== 0) {
+                totalWidth -= context.letterSpacingFU;
+            }
             const adjustment = lineWidth - totalWidth;
             let ratio;
             if (adjustment > 0 && totalStretch > 0) {
@@ -1290,6 +1311,10 @@
                     }
                 }
                 const lineText = lineTextParts.join('');
+                // Correct for trailing letter spacing at the end of the line.
+                if (context?.letterSpacingFU && naturalWidth !== 0) {
+                    naturalWidth -= context.letterSpacingFU;
+                }
                 let xOffset = 0;
                 let adjustmentRatio = 0;
                 let effectiveAlign = align;
@@ -1343,6 +1368,10 @@
                     finalNaturalWidth += item.width;
                 }
                 const finalLineText = finalLineTextParts.join('');
+                // Correct for trailing letter spacing at the end of the final line.
+                if (context?.letterSpacingFU && finalNaturalWidth !== 0) {
+                    finalNaturalWidth -= context.letterSpacingFU;
+                }
                 let finalXOffset = 0;
                 let finalEffectiveAlign = align;
                 if (align === 'justify') {
@@ -1404,9 +1433,6 @@
     }
 
     class TextMeasurer {
-        // Measures text width including letter spacing
-        // (letter spacing is added uniformly after each glyph during measurement,
-        // so the widths given to the line-breaking algorithm already account for tracking)
         static measureTextWidth(loadedFont, text, letterSpacing = 0) {
             const buffer = loadedFont.hb.createBuffer();
             buffer.addText(text);
@@ -1415,7 +1441,6 @@
             loadedFont.hb.shape(loadedFont.font, buffer, featuresString);
             const glyphInfos = buffer.json(loadedFont.font);
             const letterSpacingInFontUnits = letterSpacing * loadedFont.upem;
-            // Calculate total advance width with letter spacing
             let totalWidth = 0;
             glyphInfos.forEach((glyph) => {
                 totalWidth += glyph.ax;
@@ -1462,6 +1487,7 @@
                     disableShortLineDetection,
                     shortLineThreshold,
                     unitsPerEm: this.loadedFont.upem,
+                    letterSpacing,
                     measureText: (textToMeasure) => TextMeasurer.measureTextWidth(this.loadedFont, textToMeasure, letterSpacing // Letter spacing included in width measurements
                     )
                 });
@@ -1472,10 +1498,11 @@
                 lines = [];
                 let currentIndex = 0;
                 for (const line of linesArray) {
+                    const originalEnd = line.length === 0 ? currentIndex : currentIndex + line.length - 1;
                     lines.push({
                         text: line,
                         originalStart: currentIndex,
-                        originalEnd: currentIndex + line.length - 1,
+                        originalEnd,
                         xOffset: 0
                     });
                     currentIndex += line.length + 1;
@@ -1514,7 +1541,6 @@
     // Font file signature constants
     const FONT_SIGNATURE_TRUE_TYPE = 0x00010000;
     const FONT_SIGNATURE_OPEN_TYPE_CFF = 0x4f54544f; // 'OTTO'
-    const FONT_SIGNATURE_TRUE_TYPE_COLLECTION = 0x74746366; // 'ttcf'
     const FONT_SIGNATURE_WOFF = 0x774f4646; // 'wOFF'
     const FONT_SIGNATURE_WOFF2 = 0x774f4632; // 'wOF2'
     // Table Tags
@@ -1529,6 +1555,28 @@
     const TABLE_TAG_GSUB = 0x47535542; // 'GSUB'
     const TABLE_TAG_GPOS = 0x47504f53; // 'GPOS'
 
+    // Parses the SFNT table directory for TTF/OTF fonts
+    // Assumes the DataView is positioned at the start of an sfnt font (offset 0)
+    // Table records are 16 bytes each starting at byte offset 12
+    function parseTableDirectory(view) {
+        const numTables = view.getUint16(4);
+        const tableRecordsStart = 12;
+        const tables = new Map();
+        for (let i = 0; i < numTables; i++) {
+            const recordOffset = tableRecordsStart + i * 16;
+            // Guard against corrupt buffers that report more tables than exist
+            if (recordOffset + 16 > view.byteLength) {
+                break;
+            }
+            const tag = view.getUint32(recordOffset);
+            const checksum = view.getUint32(recordOffset + 4);
+            const offset = view.getUint32(recordOffset + 8);
+            const length = view.getUint32(recordOffset + 12);
+            tables.set(tag, { tag, checksum, offset, length });
+        }
+        return tables;
+    }
+
     class FontMetadataExtractor {
         static extractMetadata(fontBuffer) {
             if (!fontBuffer || fontBuffer.byteLength < 12) {
@@ -1538,45 +1586,19 @@
             const sfntVersion = view.getUint32(0);
             const validSignatures = [
                 FONT_SIGNATURE_TRUE_TYPE,
-                FONT_SIGNATURE_OPEN_TYPE_CFF,
-                FONT_SIGNATURE_TRUE_TYPE_COLLECTION
+                FONT_SIGNATURE_OPEN_TYPE_CFF
             ];
             if (!validSignatures.includes(sfntVersion)) {
-                throw new Error(`Invalid font format. Expected TrueType or OpenType, got signature: 0x${sfntVersion.toString(16)}`);
-            }
-            const numTables = view.getUint16(4); // OpenType header - number of tables is at offset 4
-            let isCFF = false;
-            let headTableOffset = 0;
-            let hheaTableOffset = 0;
-            let os2TableOffset = 0;
-            let statTableOffset = 0;
-            let nameTableOffset = 0;
-            let fvarTableOffset = 0;
-            for (let i = 0; i < numTables; i++) {
-                const offset = 12 + i * 16;
-                const tag = view.getUint32(offset);
-                if (tag === TABLE_TAG_CFF || tag === TABLE_TAG_CFF2) {
-                    isCFF = true;
-                }
-                else if (tag === TABLE_TAG_HEAD) {
-                    headTableOffset = view.getUint32(offset + 8);
-                }
-                else if (tag === TABLE_TAG_HHEA) {
-                    hheaTableOffset = view.getUint32(offset + 8);
-                }
-                else if (tag === TABLE_TAG_OS2) {
-                    os2TableOffset = view.getUint32(offset + 8);
-                }
-                else if (tag === TABLE_TAG_FVAR) {
-                    fvarTableOffset = view.getUint32(offset + 8);
-                }
-                else if (tag === TABLE_TAG_STAT) {
-                    statTableOffset = view.getUint32(offset + 8);
-                }
-                else if (tag === TABLE_TAG_NAME) {
-                    nameTableOffset = view.getUint32(offset + 8);
-                }
-            }
+                throw new Error(`Invalid font format. Expected TTF/OTF (or WOFF), got signature: 0x${sfntVersion.toString(16)}`);
+            }
+            const tableDirectory = parseTableDirectory(view);
+            const isCFF = tableDirectory.has(TABLE_TAG_CFF) || tableDirectory.has(TABLE_TAG_CFF2);
+            const headTableOffset = tableDirectory.get(TABLE_TAG_HEAD)?.offset ?? 0;
+            const hheaTableOffset = tableDirectory.get(TABLE_TAG_HHEA)?.offset ?? 0;
+            const os2TableOffset = tableDirectory.get(TABLE_TAG_OS2)?.offset ?? 0;
+            const fvarTableOffset = tableDirectory.get(TABLE_TAG_FVAR)?.offset ?? 0;
+            const statTableOffset = tableDirectory.get(TABLE_TAG_STAT)?.offset ?? 0;
+            const nameTableOffset = tableDirectory.get(TABLE_TAG_NAME)?.offset ?? 0;
             const unitsPerEm = headTableOffset
                 ? view.getUint16(headTableOffset + 18)
                 : 1000;
@@ -1619,23 +1641,10 @@
         }
         static extractFeatureTags(fontBuffer) {
             const view = new DataView(fontBuffer);
-            const numTables = view.getUint16(4);
-            let gsubTableOffset = 0;
-            let gposTableOffset = 0;
-            let nameTableOffset = 0;
-            for (let i = 0; i < numTables; i++) {
-                const offset = 12 + i * 16;
-                const tag = view.getUint32(offset);
-                if (tag === TABLE_TAG_GSUB) {
-                    gsubTableOffset = view.getUint32(offset + 8);
-                }
-                else if (tag === TABLE_TAG_GPOS) {
-                    gposTableOffset = view.getUint32(offset + 8);
-                }
-                else if (tag === TABLE_TAG_NAME) {
-                    nameTableOffset = view.getUint32(offset + 8);
-                }
-            }
+            const tableDirectory = parseTableDirectory(view);
+            const gsubTableOffset = tableDirectory.get(TABLE_TAG_GSUB)?.offset ?? 0;
+            const gposTableOffset = tableDirectory.get(TABLE_TAG_GPOS)?.offset ?? 0;
+            const nameTableOffset = tableDirectory.get(TABLE_TAG_NAME)?.offset ?? 0;
             const features = new Set();
             const featureNames = {};
             try {
@@ -1866,6 +1875,7 @@
             sfntView.setUint16(6, searchRange);
             sfntView.setUint16(8, Math.floor(Math.log2(numTables)));
             sfntView.setUint16(10, numTables * 16 - searchRange);
+            // Read and decompress table directory
             let sfntOffset = 12 + numTables * 16; // Start of table data
             const tableDirectory = [];
             // Read WOFF table directory
@@ -1948,11 +1958,10 @@
             const sfntVersion = view.getUint32(0);
             const validSignatures = [
                 FONT_SIGNATURE_TRUE_TYPE,
-                FONT_SIGNATURE_OPEN_TYPE_CFF,
-                FONT_SIGNATURE_TRUE_TYPE_COLLECTION
+                FONT_SIGNATURE_OPEN_TYPE_CFF
             ];
             if (!validSignatures.includes(sfntVersion)) {
-                throw new Error(`Invalid font format. Expected TrueType or OpenType, got signature: 0x${sfntVersion.toString(16)}`);
+                throw new Error(`Invalid font format. Expected TTF/OTF (or WOFF), got signature: 0x${sfntVersion.toString(16)}`);
             }
             const { hb, module } = await this.getHarfBuzzInstance();
             try {
@@ -1989,7 +1998,8 @@
                     isVariable,
                     variationAxes,
                     availableFeatures: featureData?.tags,
-                    featureNames: featureData?.names
+                    featureNames: featureData?.names,
+                    _buffer: fontBuffer // For stable font ID generation
                 };
             }
             catch (error) {
@@ -2019,7 +2029,91 @@
         }
     }
 
+    const SAFE_LANGUAGE_RE = /^[a-z]{2,3}(?:-[a-z0-9]{2,16})*$/i;
+    // Built-in patterns shipped with three-text (matches files in src/hyphenation/*)
+    const BUILTIN_PATTERN_LANGUAGES = new Set([
+        'af',
+        'as',
+        'be',
+        'bg',
+        'bn',
+        'ca',
+        'cs',
+        'cy',
+        'da',
+        'de-1996',
+        'el-monoton',
+        'el-polyton',
+        'en-gb',
+        'en-us',
+        'eo',
+        'es',
+        'et',
+        'eu',
+        'fi',
+        'fr',
+        'fur',
+        'ga',
+        'gl',
+        'gu',
+        'hi',
+        'hr',
+        'hsb',
+        'hu',
+        'hy',
+        'ia',
+        'id',
+        'is',
+        'it',
+        'ka',
+        'kmr',
+        'kn',
+        'la',
+        'lt',
+        'lv',
+        'mk',
+        'ml',
+        'mn-cyrl',
+        'mr',
+        'mul-ethi',
+        'nb',
+        'nl',
+        'nn',
+        'oc',
+        'or',
+        'pa',
+        'pl',
+        'pms',
+        'pt',
+        'rm',
+        'ro',
+        'ru',
+        'sa',
+        'sh-cyrl',
+        'sh-latn',
+        'sk',
+        'sl',
+        'sq',
+        'sr-cyrl',
+        'sv',
+        'ta',
+        'te',
+        'th',
+        'tk',
+        'tr',
+        'uk',
+        'zh-latn-pinyin'
+    ]);
     async function loadPattern(language, patternsPath) {
+        if (!SAFE_LANGUAGE_RE.test(language)) {
+            throw new Error(`Invalid hyphenation language code "${language}". Expected e.g. "en-us".`);
+        }
+        // When no patternsPath is provided, we only allow the built-in set shipped with
+        // three-text to avoid accidental arbitrary imports / path traversal
+        if (!patternsPath && !BUILTIN_PATTERN_LANGUAGES.has(language)) {
+            throw new Error(`Unsupported hyphenation language "${language}". ` +
+                `Use a built-in language (e.g. "en-us") or register patterns via Text.registerPattern("${language}", pattern).`);
+        }
         {
             const safeLangName = language.replace(/-/g, '_');
             const globalName = `ThreeTextPatterns_${safeLangName}`;
@@ -2210,108 +2304,233 @@
             return this.x === v.x && this.y === v.y && this.z === v.z;
         }
     }
-    // 3D Bounding Box
-    class Box3 {
-        constructor(min = new Vec3(Infinity, Infinity, Infinity), max = new Vec3(-Infinity, -Infinity, -Infinity)) {
-            this.min = min;
-            this.max = max;
-        }
-        set(min, max) {
-            this.min.copy(min);
-            this.max.copy(max);
-            return this;
+
+    // Generic LRU (Least Recently Used) cache with optional memory-based eviction
+    class LRUCache {
+        constructor(options = {}) {
+            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
+            };
         }
-        setFromPoints(points) {
-            this.makeEmpty();
-            for (let i = 0; i < points.length; i++) {
-                this.expandByPoint(points[i]);
+        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;
         }
-        makeEmpty() {
-            this.min.x = this.min.y = this.min.z = Infinity;
-            this.max.x = this.max.y = this.max.z = -Infinity;
-            return this;
+        has(key) {
+            return this.cache.has(key);
         }
-        isEmpty() {
-            return (this.max.x < this.min.x ||
-                this.max.y < this.min.y ||
-                this.max.z < this.min.z);
-        }
-        expandByPoint(point) {
-            this.min.x = Math.min(this.min.x, point.x);
-            this.min.y = Math.min(this.min.y, point.y);
-            this.min.z = Math.min(this.min.z, point.z);
-            this.max.x = Math.max(this.max.x, point.x);
-            this.max.y = Math.max(this.max.y, point.y);
-            this.max.z = Math.max(this.max.z, point.z);
-            return this;
+        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;
         }
-        expandByScalar(scalar) {
-            this.min.x -= scalar;
-            this.min.y -= scalar;
-            this.min.z -= scalar;
-            this.max.x += scalar;
-            this.max.y += scalar;
-            this.max.z += scalar;
-            return this;
+        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;
         }
-        containsPoint(point) {
-            return (point.x >= this.min.x &&
-                point.x <= this.max.x &&
-                point.y >= this.min.y &&
-                point.y <= this.max.y &&
-                point.z >= this.min.z &&
-                point.z <= this.max.z);
-        }
-        containsBox(box) {
-            return (this.min.x <= box.min.x &&
-                box.max.x <= this.max.x &&
-                this.min.y <= box.min.y &&
-                box.max.y <= this.max.y &&
-                this.min.z <= box.min.z &&
-                box.max.z <= this.max.z);
-        }
-        intersectsBox(box) {
-            return (box.max.x >= this.min.x &&
-                box.min.x <= this.max.x &&
-                box.max.y >= this.min.y &&
-                box.min.y <= this.max.y &&
-                box.max.z >= this.min.z &&
-                box.min.z <= this.max.z);
-        }
-        getCenter(target = new Vec3()) {
-            return this.isEmpty()
-                ? target.set(0, 0, 0)
-                : target.set((this.min.x + this.max.x) * 0.5, (this.min.y + this.max.y) * 0.5, (this.min.z + this.max.z) * 0.5);
-        }
-        getSize(target = new Vec3()) {
-            return this.isEmpty()
-                ? target.set(0, 0, 0)
-                : target.set(this.max.x - this.min.x, this.max.y - this.min.y, this.max.z - this.min.z);
+        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
+            };
         }
-        clone() {
-            return new Box3(this.min.clone(), this.max.clone());
+        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
+            };
         }
-        copy(box) {
-            this.min.copy(box.min);
-            this.max.copy(box.max);
-            return this;
+        keys() {
+            const keys = [];
+            let current = this.head;
+            while (current) {
+                keys.push(current.key);
+                current = current.next;
+            }
+            return keys;
         }
-        union(box) {
-            this.min.x = Math.min(this.min.x, box.min.x);
-            this.min.y = Math.min(this.min.y, box.min.y);
-            this.min.z = Math.min(this.min.z, box.min.z);
-            this.max.x = Math.max(this.max.x, box.max.x);
-            this.max.y = Math.max(this.max.y, box.max.y);
-            this.max.z = Math.max(this.max.z, box.max.z);
-            return this;
+        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);
+            }
         }
-        equals(box) {
-            return box.min.equals(this.min) && box.max.equals(this.max);
+        moveToHead(node) {
+            if (node === this.head)
+                return;
+            this.removeNode(node);
+            this.addToHead(node);
         }
     }
 
+    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 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
+    });
+
     var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
     function getDefaultExportFromCjs (x) {
@@ -2568,69 +2787,137 @@
     class Extruder {
         constructor() { }
         extrude(geometry, depth = 0, unitsPerEm) {
-            const vertices = [];
-            const normals = [];
-            const indices = [];
-            if (depth === 0) {
-                this.addFlatFaces(geometry.triangles, vertices, normals, indices);
-            }
-            else {
-                this.addFrontAndBackFaces(geometry.triangles, vertices, normals, indices, depth, unitsPerEm);
+            const points = geometry.triangles.vertices;
+            const triangleIndices = geometry.triangles.indices;
+            const numPoints = points.length / 2;
+            // Count side-wall segments (each segment emits 4 vertices + 6 indices)
+            let sideSegments = 0;
+            if (depth !== 0) {
                 for (const contour of geometry.contours) {
-                    this.addSideWalls(contour, vertices, normals, indices, depth);
-                }
-            }
-            return { vertices, normals, indices };
-        }
-        addFlatFaces(triangulatedData, vertices, normals, indices) {
-            const baseIndex = vertices.length / 3;
-            const points = triangulatedData.vertices;
-            const triangleIndices = triangulatedData.indices;
-            for (let i = 0; i < points.length; i += 2) {
-                vertices.push(points[i], points[i + 1], 0);
-                normals.push(0, 0, -1);
-            }
-            // Add triangle indices
-            for (let i = 0; i < triangleIndices.length; i++) {
-                indices.push(baseIndex + triangleIndices[i]);
-            }
-        }
-        addFrontAndBackFaces(triangulatedData, vertices, normals, indices, depth, unitsPerEm) {
-            const baseIndex = vertices.length / 3;
-            const points = triangulatedData.vertices;
-            const triangleIndices = triangulatedData.indices;
-            for (let i = 0; i < points.length; i += 2) {
-                vertices.push(points[i], points[i + 1], 0);
-                normals.push(0, 0, -1);
-            }
-            // Minimum offset to prevent z-fighting between front and back faces
+                    // Each contour is a flat [x0,y0,x1,y1,...] array; side walls connect consecutive points
+                    // Contours are expected to be closed (last point repeats first), so segments = (nPoints - 1)
+                    const contourPoints = contour.length / 2;
+                    if (contourPoints >= 2)
+                        sideSegments += contourPoints - 1;
+                }
+            }
+            const sideVertexCount = depth === 0 ? 0 : sideSegments * 4;
+            const baseVertexCount = depth === 0 ? numPoints : numPoints * 2;
+            const vertexCount = baseVertexCount + sideVertexCount;
+            const vertices = new Float32Array(vertexCount * 3);
+            const normals = new Float32Array(vertexCount * 3);
+            const indexCount = depth === 0
+                ? triangleIndices.length
+                : triangleIndices.length * 2 + sideSegments * 6;
+            const indices = new Uint32Array(indexCount);
+            if (depth === 0) {
+                // Flat faces only
+                let vPos = 0;
+                for (let i = 0; i < points.length; i += 2) {
+                    vertices[vPos] = points[i];
+                    vertices[vPos + 1] = points[i + 1];
+                    vertices[vPos + 2] = 0;
+                    normals[vPos] = 0;
+                    normals[vPos + 1] = 0;
+                    normals[vPos + 2] = -1;
+                    vPos += 3;
+                }
+                for (let i = 0; i < triangleIndices.length; i++) {
+                    indices[i] = triangleIndices[i];
+                }
+                return { vertices, normals, indices };
+            }
+            // Front/back faces
             const minBackOffset = unitsPerEm * 0.000025;
             const backZ = depth <= minBackOffset ? minBackOffset : depth;
-            for (let i = 0; i < points.length; i += 2) {
-                vertices.push(points[i], points[i + 1], backZ);
-                normals.push(0, 0, 1);
-            }
-            const numPoints = points.length / 2;
+            // Fill front vertices/normals (0..numPoints-1)
+            for (let p = 0, vi = 0; p < points.length; p += 2, vi++) {
+                const base = vi * 3;
+                vertices[base] = points[p];
+                vertices[base + 1] = points[p + 1];
+                vertices[base + 2] = 0;
+                normals[base] = 0;
+                normals[base + 1] = 0;
+                normals[base + 2] = -1;
+            }
+            // Fill back vertices/normals (numPoints..2*numPoints-1)
+            for (let p = 0, vi = 0; p < points.length; p += 2, vi++) {
+                const base = (numPoints + vi) * 3;
+                vertices[base] = points[p];
+                vertices[base + 1] = points[p + 1];
+                vertices[base + 2] = backZ;
+                normals[base] = 0;
+                normals[base + 1] = 0;
+                normals[base + 2] = 1;
+            }
+            // Front indices
             for (let i = 0; i < triangleIndices.length; i++) {
-                indices.push(baseIndex + triangleIndices[i]);
-            }
-            for (let i = triangleIndices.length - 1; i >= 0; i--) {
-                indices.push(baseIndex + triangleIndices[i] + numPoints);
+                indices[i] = triangleIndices[i];
             }
-        }
-        addSideWalls(points, vertices, normals, indices, depth) {
-            for (let i = 0; i < points.length - 2; i += 2) {
-                const p0x = points[i];
-                const p0y = points[i + 1];
-                const p1x = points[i + 2];
-                const p1y = points[i + 3];
-                const edge = new Vec2(p1x - p0x, p1y - p0y);
-                const normal = new Vec2(edge.y, -edge.x).normalize();
-                const wallBaseIndex = vertices.length / 3;
-                vertices.push(p0x, p0y, 0, p1x, p1y, 0, p0x, p0y, depth, p1x, p1y, depth);
-                normals.push(normal.x, normal.y, 0, normal.x, normal.y, 0, normal.x, normal.y, 0, normal.x, normal.y, 0);
-                indices.push(wallBaseIndex, wallBaseIndex + 1, wallBaseIndex + 2, wallBaseIndex + 1, wallBaseIndex + 3, wallBaseIndex + 2);
+            // Back indices (reverse winding + offset)
+            for (let i = 0; i < triangleIndices.length; i++) {
+                indices[triangleIndices.length + i] =
+                    triangleIndices[triangleIndices.length - 1 - i] + numPoints;
+            }
+            // Side walls
+            let nextVertex = numPoints * 2;
+            let idxPos = triangleIndices.length * 2;
+            for (const contour of geometry.contours) {
+                for (let i = 0; i < contour.length - 2; i += 2) {
+                    const p0x = contour[i];
+                    const p0y = contour[i + 1];
+                    const p1x = contour[i + 2];
+                    const p1y = contour[i + 3];
+                    // Unit normal for the wall quad (per-edge)
+                    const ex = p1x - p0x;
+                    const ey = p1y - p0y;
+                    const lenSq = ex * ex + ey * ey;
+                    let nx = 0;
+                    let ny = 0;
+                    if (lenSq > 0) {
+                        const invLen = 1 / Math.sqrt(lenSq);
+                        nx = ey * invLen;
+                        ny = -ex * invLen;
+                    }
+                    const baseVertex = nextVertex;
+                    const base = baseVertex * 3;
+                    // 4 vertices (two at z=0, two at z=depth)
+                    vertices[base] = p0x;
+                    vertices[base + 1] = p0y;
+                    vertices[base + 2] = 0;
+                    vertices[base + 3] = p1x;
+                    vertices[base + 4] = p1y;
+                    vertices[base + 5] = 0;
+                    vertices[base + 6] = p0x;
+                    vertices[base + 7] = p0y;
+                    vertices[base + 8] = backZ;
+                    vertices[base + 9] = p1x;
+                    vertices[base + 10] = p1y;
+                    vertices[base + 11] = backZ;
+                    // Normals (same for all 4 wall vertices)
+                    normals[base] = nx;
+                    normals[base + 1] = ny;
+                    normals[base + 2] = 0;
+                    normals[base + 3] = nx;
+                    normals[base + 4] = ny;
+                    normals[base + 5] = 0;
+                    normals[base + 6] = nx;
+                    normals[base + 7] = ny;
+                    normals[base + 8] = 0;
+                    normals[base + 9] = nx;
+                    normals[base + 10] = ny;
+                    normals[base + 11] = 0;
+                    // Indices (two triangles)
+                    indices[idxPos++] = baseVertex;
+                    indices[idxPos++] = baseVertex + 1;
+                    indices[idxPos++] = baseVertex + 2;
+                    indices[idxPos++] = baseVertex + 1;
+                    indices[idxPos++] = baseVertex + 3;
+                    indices[idxPos++] = baseVertex + 2;
+                    nextVertex += 4;
+                }
             }
+            return { vertices, normals, indices };
         }
     }
 
@@ -2641,18 +2928,21 @@
             perfLogger.start('BoundaryClusterer.cluster', {
                 glyphCount: glyphContoursList.length
             });
-            if (glyphContoursList.length === 0) {
+            const n = glyphContoursList.length;
+            if (n === 0) {
                 perfLogger.end('BoundaryClusterer.cluster');
                 return [];
             }
+            if (n === 1) {
+                perfLogger.end('BoundaryClusterer.cluster');
+                return [[0]];
+            }
             const result = this.clusterSweepLine(glyphContoursList, positions);
             perfLogger.end('BoundaryClusterer.cluster');
             return result;
         }
         clusterSweepLine(glyphContoursList, positions) {
             const n = glyphContoursList.length;
-            if (n <= 1)
-                return n === 0 ? [] : [[0]];
             const bounds = new Array(n);
             const events = new Array(2 * n);
             let eventIndex = 0;
@@ -2672,7 +2962,6 @@
                 const py = find(y);
                 if (px === py)
                     return;
-                // Union by rank, attach smaller tree under larger tree
                 if (rank[px] < rank[py]) {
                     parent[px] = py;
                 }
@@ -2688,8 +2977,6 @@
             for (const [, eventType, glyphIndex] of events) {
                 if (eventType === 0) {
                     const bounds1 = bounds[glyphIndex];
-                    // Check y-overlap with all currently active glyphs
-                    // (x-overlap is guaranteed by the sweep line)
                     for (const activeIndex of active) {
                         const bounds2 = bounds[activeIndex];
                         if (bounds1.minY < bounds2.maxY + OVERLAP_EPSILON &&
@@ -2706,10 +2993,12 @@
             const clusters = new Map();
             for (let i = 0; i < n; i++) {
                 const root = find(i);
-                if (!clusters.has(root)) {
-                    clusters.set(root, []);
+                let list = clusters.get(root);
+                if (!list) {
+                    list = [];
+                    clusters.set(root, list);
                 }
-                clusters.get(root).push(i);
+                list.push(i);
             }
             return Array.from(clusters.values());
         }
@@ -2941,13 +3230,17 @@
                 const prev = points[i - 1];
                 const current = points[i];
                 const next = points[i + 1];
-                const v1 = new Vec2(current.x - prev.x, current.y - prev.y);
-                const v2 = new Vec2(next.x - current.x, next.y - current.y);
-                const angle = Math.abs(v1.angle() - v2.angle());
-                const normalizedAngle = Math.min(angle, 2 * Math.PI - angle);
-                if (normalizedAngle > threshold ||
-                    v1.length() < this.config.minSegmentLength ||
-                    v2.length() < this.config.minSegmentLength) {
+                const v1x = current.x - prev.x;
+                const v1y = current.y - prev.y;
+                const v2x = next.x - current.x;
+                const v2y = next.y - current.y;
+                const angle = Math.abs(Math.atan2(v1x * v2y - v1y * v2x, v1x * v2x + v1y * v2y));
+                const v1LenSq = v1x * v1x + v1y * v1y;
+                const v2LenSq = v2x * v2x + v2y * v2y;
+                const minLenSq = this.config.minSegmentLength * this.config.minSegmentLength;
+                if (angle > threshold ||
+                    v1LenSq < minLenSq ||
+                    v2LenSq < minLenSq) {
                     result.push(current);
                 }
                 else {
@@ -3067,9 +3360,13 @@
                     const angleTolerance = this.curveFidelityConfig.angleTolerance ??
                         DEFAULT_CURVE_FIDELITY.angleTolerance;
                     if (angleTolerance > 0) {
-                        let da = Math.abs(Math.atan2(y3 - y2, x3 - x2) - Math.atan2(y2 - y1, x2 - x1));
-                        if (da >= Math.PI)
-                            da = 2 * Math.PI - da;
+                        // Angle between segments (p1->p2) and (p2->p3).
+                        // Using atan2(cross, dot) avoids computing 2 separate atan2() values + wrap logic.
+                        const v1x = x2 - x1;
+                        const v1y = y2 - y1;
+                        const v2x = x3 - x2;
+                        const v2y = y3 - y2;
+                        const da = Math.abs(Math.atan2(v1x * v2y - v1y * v2x, v1x * v2x + v1y * v2y));
                         if (da < angleTolerance) {
                             this.addPoint(x2, y2, points);
                             return;
@@ -3164,9 +3461,12 @@
                         const angleTolerance = this.curveFidelityConfig.angleTolerance ??
                             DEFAULT_CURVE_FIDELITY.angleTolerance;
                         if (angleTolerance > 0) {
-                            let da1 = Math.abs(Math.atan2(y4 - y3, x4 - x3) - Math.atan2(y3 - y2, x3 - x2));
-                            if (da1 >= Math.PI)
-                                da1 = 2 * Math.PI - da1;
+                            // Angle between segments (p2->p3) and (p3->p4)
+                            const v1x = x3 - x2;
+                            const v1y = y3 - y2;
+                            const v2x = x4 - x3;
+                            const v2y = y4 - y3;
+                            const da1 = Math.abs(Math.atan2(v1x * v2y - v1y * v2x, v1x * v2x + v1y * v2y));
                             if (da1 < angleTolerance) {
                                 this.addPoint(x2, y2, points);
                                 this.addPoint(x3, y3, points);
@@ -3186,9 +3486,12 @@
                         const angleTolerance = this.curveFidelityConfig.angleTolerance ??
                             DEFAULT_CURVE_FIDELITY.angleTolerance;
                         if (angleTolerance > 0) {
-                            let da1 = Math.abs(Math.atan2(y3 - y2, x3 - x2) - Math.atan2(y2 - y1, x2 - x1));
-                            if (da1 >= Math.PI)
-                                da1 = 2 * Math.PI - da1;
+                            // Angle between segments (p1->p2) and (p2->p3)
+                            const v1x = x2 - x1;
+                            const v1y = y2 - y1;
+                            const v2x = x3 - x2;
+                            const v2y = y3 - y2;
+                            const da1 = Math.abs(Math.atan2(v1x * v2y - v1y * v2x, v1x * v2x + v1y * v2y));
                             if (da1 < angleTolerance) {
                                 this.addPoint(x2, y2, points);
                                 this.addPoint(x3, y3, points);
@@ -3208,12 +3511,18 @@
                         const angleTolerance = this.curveFidelityConfig.angleTolerance ??
                             DEFAULT_CURVE_FIDELITY.angleTolerance;
                         if (angleTolerance > 0) {
-                            let da1 = Math.abs(Math.atan2(y3 - y2, x3 - x2) - Math.atan2(y2 - y1, x2 - x1));
-                            let da2 = Math.abs(Math.atan2(y4 - y3, x4 - x3) - Math.atan2(y3 - y2, x3 - x2));
-                            if (da1 >= Math.PI)
-                                da1 = 2 * Math.PI - da1;
-                            if (da2 >= Math.PI)
-                                da2 = 2 * Math.PI - da2;
+                            // da1: angle between (p1->p2) and (p2->p3)
+                            const a1x = x2 - x1;
+                            const a1y = y2 - y1;
+                            const a2x = x3 - x2;
+                            const a2y = y3 - y2;
+                            const da1 = Math.abs(Math.atan2(a1x * a2y - a1y * a2x, a1x * a2x + a1y * a2y));
+                            // da2: angle between (p2->p3) and (p3->p4)
+                            const b1x = a2x;
+                            const b1y = a2y;
+                            const b2x = x4 - x3;
+                            const b2y = y4 - y3;
+                            const da2 = Math.abs(Math.atan2(b1x * b2y - b1y * b2x, b1x * b2x + b1y * b2y));
                             if (da1 + da2 < angleTolerance) {
                                 this.addPoint(x2, y2, points);
                                 this.addPoint(x3, y3, points);
@@ -3475,6 +3784,9 @@
                 this.collector.updatePosition(dx, dy);
             }
         }
+        setCollector(collector) {
+            this.collector = collector;
+        }
         createDrawFuncs(font, collector) {
             if (!font || !font.module || !font.hb) {
                 throw new Error('Invalid font object');
@@ -3551,229 +3863,73 @@
             this.collector = undefined;
         }
     }
+    // Share a single DrawCallbackHandler per HarfBuzz module to avoid leaking
+    // wasm function pointers when users create many Text instances
+    const sharedDrawCallbackHandlers = new WeakMap();
+    function getSharedDrawCallbackHandler(font) {
+        const key = font.module;
+        const existing = sharedDrawCallbackHandlers.get(key);
+        if (existing)
+            return existing;
+        const handler = new DrawCallbackHandler();
+        sharedDrawCallbackHandlers.set(key, handler);
+        return handler;
+    }
 
-    // Generic LRU (Least Recently Used) cache with optional memory-based eviction
-    class LRUCache {
-        constructor(options = {}) {
-            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;
-            }
-        }
-        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;
-        }
-        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;
-        }
-        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) {
-            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);
-            }
-        }
-        moveToHead(node) {
-            if (node === this.head)
-                return;
-            this.removeNode(node);
-            this.addToHead(node);
-        }
-    }
-
-    const CONTOUR_CACHE_MAX_ENTRIES = 1000;
-    const WORD_CACHE_MAX_ENTRIES = 1000;
     class GlyphGeometryBuilder {
         constructor(cache, loadedFont) {
             this.fontId = 'default';
+            this.cacheKeyPrefix = 'default';
             this.cache = cache;
             this.loadedFont = loadedFont;
             this.tessellator = new Tessellator();
             this.extruder = new Extruder();
             this.clusterer = new BoundaryClusterer();
             this.collector = new GlyphContourCollector();
-            this.drawCallbacks = new DrawCallbackHandler();
+            this.drawCallbacks = getSharedDrawCallbackHandler(this.loadedFont);
             this.drawCallbacks.createDrawFuncs(this.loadedFont, this.collector);
-            this.contourCache = new LRUCache({
-                maxEntries: CONTOUR_CACHE_MAX_ENTRIES,
-                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
-                }
-            });
-            this.wordCache = new LRUCache({
-                maxEntries: WORD_CACHE_MAX_ENTRIES,
-                calculateSize: (data) => {
-                    let size = data.vertices.length * 4;
-                    size += data.normals.length * 4;
-                    size += data.indices.length * data.indices.BYTES_PER_ELEMENT;
-                    return size;
-                }
-            });
+            this.contourCache = globalContourCache;
+            this.wordCache = globalWordCache;
+            this.clusteringCache = globalClusteringCache;
         }
         getOptimizationStats() {
             return this.collector.getOptimizationStats();
         }
         setCurveFidelityConfig(config) {
+            this.curveFidelityConfig = config;
             this.collector.setCurveFidelityConfig(config);
+            this.updateCacheKeyPrefix();
         }
         setGeometryOptimization(options) {
+            this.geometryOptimizationOptions = options;
             this.collector.setGeometryOptimization(options);
+            this.updateCacheKeyPrefix();
         }
         setFontId(fontId) {
             this.fontId = fontId;
+            this.updateCacheKeyPrefix();
+        }
+        updateCacheKeyPrefix() {
+            this.cacheKeyPrefix = `${this.fontId}__${this.getGeometryConfigSignature()}`;
+        }
+        getGeometryConfigSignature() {
+            const distanceTolerance = this.curveFidelityConfig?.distanceTolerance ??
+                DEFAULT_CURVE_FIDELITY.distanceTolerance;
+            const angleTolerance = this.curveFidelityConfig?.angleTolerance ??
+                DEFAULT_CURVE_FIDELITY.angleTolerance;
+            const enabled = this.geometryOptimizationOptions?.enabled ??
+                DEFAULT_OPTIMIZATION_CONFIG.enabled;
+            const areaThreshold = this.geometryOptimizationOptions?.areaThreshold ??
+                DEFAULT_OPTIMIZATION_CONFIG.areaThreshold;
+            const colinearThreshold = this.geometryOptimizationOptions?.colinearThreshold ??
+                DEFAULT_OPTIMIZATION_CONFIG.colinearThreshold;
+            const minSegmentLength = this.geometryOptimizationOptions?.minSegmentLength ??
+                DEFAULT_OPTIMIZATION_CONFIG.minSegmentLength;
+            // Use fixed precision to keep cache keys stable and avoid float noise
+            return [
+                `cf:${distanceTolerance.toFixed(4)},${angleTolerance.toFixed(4)}`,
+                `opt:${enabled ? 1 : 0},${areaThreshold.toFixed(4)},${colinearThreshold.toFixed(6)},${minSegmentLength.toFixed(4)}`
+            ].join('|');
         }
         // Build instanced geometry from glyph contours
         buildInstancedGeometry(clustersByLine, depth, removeOverlaps, isCFF, separateGlyphs = false, coloredTextIndices) {
@@ -3783,9 +3939,58 @@
                 depth,
                 removeOverlaps
             });
-            const vertices = [];
-            const normals = [];
-            const indices = [];
+            // Growable typed arrays; slice to final size at end
+            let vertexBuffer = new Float32Array(1024);
+            let normalBuffer = new Float32Array(1024);
+            let indexBuffer = new Uint32Array(1024);
+            let vertexPos = 0; // float index (multiple of 3)
+            let normalPos = 0; // float index (multiple of 3)
+            let indexPos = 0; // index count
+            const ensureFloatCapacity = (buffer, needed) => {
+                if (needed <= buffer.length)
+                    return buffer;
+                let nextSize = buffer.length;
+                while (nextSize < needed)
+                    nextSize *= 2;
+                const next = new Float32Array(nextSize);
+                next.set(buffer);
+                return next;
+            };
+            const ensureIndexCapacity = (buffer, needed) => {
+                if (needed <= buffer.length)
+                    return buffer;
+                let nextSize = buffer.length;
+                while (nextSize < needed)
+                    nextSize *= 2;
+                const next = new Uint32Array(nextSize);
+                next.set(buffer);
+                return next;
+            };
+            const appendGeometryToBuffers = (data, position, vertexOffset) => {
+                const v = data.vertices;
+                const n = data.normals;
+                const idx = data.indices;
+                // Grow buffers as needed
+                vertexBuffer = ensureFloatCapacity(vertexBuffer, vertexPos + v.length);
+                normalBuffer = ensureFloatCapacity(normalBuffer, normalPos + n.length);
+                indexBuffer = ensureIndexCapacity(indexBuffer, indexPos + idx.length);
+                // Vertices: translate by position
+                const px = position.x;
+                const py = position.y;
+                const pz = position.z;
+                for (let j = 0; j < v.length; j += 3) {
+                    vertexBuffer[vertexPos++] = v[j] + px;
+                    vertexBuffer[vertexPos++] = v[j + 1] + py;
+                    vertexBuffer[vertexPos++] = v[j + 2] + pz;
+                }
+                // Normals: straight copy
+                normalBuffer.set(n, normalPos);
+                normalPos += n.length;
+                // Indices: copy with vertex offset
+                for (let j = 0; j < idx.length; j++) {
+                    indexBuffer[indexPos++] = idx[j] + vertexOffset;
+                }
+            };
             const glyphInfos = [];
             const planeBounds = {
                 min: { x: Infinity, y: Infinity, z: 0 },
@@ -3794,83 +3999,126 @@
             for (let lineIndex = 0; lineIndex < clustersByLine.length; lineIndex++) {
                 const line = clustersByLine[lineIndex];
                 for (const cluster of line) {
-                    // Step 1: Get contours for all glyphs in the cluster
                     const clusterGlyphContours = [];
                     for (const glyph of cluster.glyphs) {
                         clusterGlyphContours.push(this.getContoursForGlyph(glyph.g));
                     }
-                    // Step 2: Check for overlaps within the cluster
-                    const relativePositions = cluster.glyphs.map((g) => new Vec3(g.x, g.y, 0));
-                    const boundaryGroups = this.clusterer.cluster(clusterGlyphContours, relativePositions);
-                    const clusterHasColoredGlyphs = coloredTextIndices &&
-                        cluster.glyphs.some((g) => coloredTextIndices.has(g.absoluteTextIndex));
-                    // Force glyph-level caching if:
-                    // - separateGlyphs flag is set (for shader attributes), OR
-                    // - cluster contains selectively colored text (needs separate vertex ranges per glyph)
-                    const forceSeparate = separateGlyphs || clusterHasColoredGlyphs;
-                    const hasOverlaps = forceSeparate
-                        ? false
-                        : boundaryGroups.some((group) => group.length > 1);
-                    if (hasOverlaps) {
-                        // Cluster-level caching
-                        const clusterKey = `${this.fontId}_${cluster.text}_${depth}_${removeOverlaps}`;
-                        let cachedCluster = this.wordCache.get(clusterKey);
-                        if (!cachedCluster) {
-                            const clusterPaths = [];
-                            for (let i = 0; i < clusterGlyphContours.length; i++) {
-                                const glyphContours = clusterGlyphContours[i];
-                                const glyph = cluster.glyphs[i];
-                                for (const path of glyphContours.paths) {
-                                    clusterPaths.push({
-                                        ...path,
-                                        points: path.points.map((p) => new Vec2(p.x + (glyph.x ?? 0), p.y + (glyph.y ?? 0)))
-                                    });
+                    let boundaryGroups;
+                    if (cluster.glyphs.length <= 1) {
+                        boundaryGroups = [[0]];
+                    }
+                    else {
+                        // Check clustering cache (same text + glyph IDs = same overlap groups)
+                        // Key must be font-specific; glyph ids/bounds differ between fonts
+                        const cacheKey = `${this.cacheKeyPrefix}_${cluster.text}`;
+                        const cached = this.clusteringCache.get(cacheKey);
+                        let isValid = false;
+                        if (cached && cached.glyphIds.length === cluster.glyphs.length) {
+                            isValid = true;
+                            for (let i = 0; i < cluster.glyphs.length; i++) {
+                                if (cached.glyphIds[i] !== cluster.glyphs[i].g) {
+                                    isValid = false;
+                                    break;
                                 }
                             }
-                            cachedCluster = this.tessellateGlyphCluster(clusterPaths, depth, isCFF);
-                            this.wordCache.set(clusterKey, cachedCluster);
                         }
-                        const vertexOffset = vertices.length / 3;
-                        this.appendGeometry(vertices, normals, indices, cachedCluster, cluster.position, vertexOffset);
-                        const clusterVertexCount = cachedCluster.vertices.length / 3;
-                        for (let i = 0; i < cluster.glyphs.length; i++) {
-                            const glyph = cluster.glyphs[i];
-                            const glyphContours = clusterGlyphContours[i];
-                            const absoluteGlyphPosition = new Vec3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
-                            const glyphInfo = this.createGlyphInfo(glyph, vertexOffset, clusterVertexCount, absoluteGlyphPosition, glyphContours, depth);
-                            glyphInfos.push(glyphInfo);
-                            this.updatePlaneBounds(glyphInfo.bounds, planeBounds);
+                        if (isValid && cached) {
+                            boundaryGroups = cached.groups;
+                        }
+                        else {
+                            const relativePositions = cluster.glyphs.map((g) => new Vec3(g.x ?? 0, g.y ?? 0, 0));
+                            boundaryGroups = this.clusterer.cluster(clusterGlyphContours, relativePositions);
+                            this.clusteringCache.set(cacheKey, {
+                                glyphIds: cluster.glyphs.map(g => g.g),
+                                groups: boundaryGroups
+                            });
                         }
                     }
-                    else {
-                        // Glyph-level caching
-                        for (let i = 0; i < cluster.glyphs.length; i++) {
-                            const glyph = cluster.glyphs[i];
-                            const glyphContours = clusterGlyphContours[i];
-                            const glyphPosition = new Vec3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
-                            // Skip glyphs with no paths (spaces, zero-width characters, etc.)
-                            if (glyphContours.paths.length === 0) {
-                                const glyphInfo = this.createGlyphInfo(glyph, 0, 0, glyphPosition, glyphContours, depth);
+                    const clusterHasColoredGlyphs = coloredTextIndices &&
+                        cluster.glyphs.some((g) => coloredTextIndices.has(g.absoluteTextIndex));
+                    // Use glyph-level caching when separateGlyphs is set or when cluster contains colored text
+                    const forceSeparate = separateGlyphs || clusterHasColoredGlyphs;
+                    // Iterate over the geometric groups identified by BoundaryClusterer
+                    // logical groups (words) are now split into geometric sub-groups (e.g. "aa", "XX", "bb")
+                    for (const groupIndices of boundaryGroups) {
+                        const isOverlappingGroup = groupIndices.length > 1;
+                        const shouldCluster = isOverlappingGroup && !forceSeparate;
+                        if (shouldCluster) {
+                            // Cluster-level caching for this specific group of overlapping glyphs
+                            const subClusterGlyphs = groupIndices.map((i) => cluster.glyphs[i]);
+                            const clusterKey = this.getClusterKey(subClusterGlyphs, depth, removeOverlaps);
+                            let cachedCluster = this.wordCache.get(clusterKey);
+                            if (!cachedCluster) {
+                                const clusterPaths = [];
+                                const refX = subClusterGlyphs[0].x ?? 0;
+                                const refY = subClusterGlyphs[0].y ?? 0;
+                                for (let i = 0; i < groupIndices.length; i++) {
+                                    const originalIndex = groupIndices[i];
+                                    const glyphContours = clusterGlyphContours[originalIndex];
+                                    const glyph = cluster.glyphs[originalIndex];
+                                    const relX = (glyph.x ?? 0) - refX;
+                                    const relY = (glyph.y ?? 0) - refY;
+                                    for (const path of glyphContours.paths) {
+                                        clusterPaths.push({
+                                            ...path,
+                                            points: path.points.map((p) => new Vec2(p.x + relX, p.y + relY))
+                                        });
+                                    }
+                                }
+                                cachedCluster = this.tessellateGlyphCluster(clusterPaths, depth, isCFF);
+                                this.wordCache.set(clusterKey, cachedCluster);
+                            }
+                            // Calculate the absolute position of this sub-cluster based on its first glyph
+                            // (since the cached geometry is relative to that first glyph)
+                            const firstGlyphInGroup = subClusterGlyphs[0];
+                            const groupPosition = new Vec3(cluster.position.x + (firstGlyphInGroup.x ?? 0), cluster.position.y + (firstGlyphInGroup.y ?? 0), cluster.position.z);
+                            const vertexOffset = vertexPos / 3;
+                            appendGeometryToBuffers(cachedCluster, groupPosition, vertexOffset);
+                            const clusterVertexCount = cachedCluster.vertices.length / 3;
+                            for (let i = 0; i < groupIndices.length; i++) {
+                                const originalIndex = groupIndices[i];
+                                const glyph = cluster.glyphs[originalIndex];
+                                const glyphContours = clusterGlyphContours[originalIndex];
+                                const absoluteGlyphPosition = new Vec3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
+                                const glyphInfo = this.createGlyphInfo(glyph, vertexOffset, clusterVertexCount, absoluteGlyphPosition, glyphContours, depth);
                                 glyphInfos.push(glyphInfo);
-                                continue;
+                                this.updatePlaneBounds(glyphInfo.bounds, planeBounds);
                             }
-                            let cachedGlyph = this.cache.get(this.fontId, glyph.g, depth, removeOverlaps);
-                            if (!cachedGlyph) {
-                                cachedGlyph = this.tessellateGlyph(glyphContours, depth, removeOverlaps, isCFF);
-                                this.cache.set(this.fontId, glyph.g, depth, removeOverlaps, cachedGlyph);
+                        }
+                        else {
+                            // Glyph-level caching (standard path for isolated glyphs or when forced separate)
+                            for (const i of groupIndices) {
+                                const glyph = cluster.glyphs[i];
+                                const glyphContours = clusterGlyphContours[i];
+                                const glyphPosition = new Vec3(cluster.position.x + (glyph.x ?? 0), cluster.position.y + (glyph.y ?? 0), cluster.position.z);
+                                // Skip glyphs with no paths (spaces, zero-width characters, etc.)
+                                if (glyphContours.paths.length === 0) {
+                                    const glyphInfo = this.createGlyphInfo(glyph, 0, 0, glyphPosition, glyphContours, depth);
+                                    glyphInfos.push(glyphInfo);
+                                    continue;
+                                }
+                                let cachedGlyph = this.cache.get(getGlyphCacheKey(this.cacheKeyPrefix, glyph.g, depth, removeOverlaps));
+                                if (!cachedGlyph) {
+                                    cachedGlyph = this.tessellateGlyph(glyphContours, depth, removeOverlaps, isCFF);
+                                    this.cache.set(getGlyphCacheKey(this.cacheKeyPrefix, glyph.g, depth, removeOverlaps), cachedGlyph);
+                                }
+                                else {
+                                    cachedGlyph.useCount++;
+                                }
+                                const vertexOffset = vertexPos / 3;
+                                appendGeometryToBuffers(cachedGlyph, glyphPosition, vertexOffset);
+                                const glyphInfo = this.createGlyphInfo(glyph, vertexOffset, cachedGlyph.vertices.length / 3, glyphPosition, glyphContours, depth);
+                                glyphInfos.push(glyphInfo);
+                                this.updatePlaneBounds(glyphInfo.bounds, planeBounds);
                             }
-                            const vertexOffset = vertices.length / 3;
-                            this.appendGeometry(vertices, normals, indices, cachedGlyph, glyphPosition, vertexOffset);
-                            const glyphInfo = this.createGlyphInfo(glyph, vertexOffset, cachedGlyph.vertices.length / 3, glyphPosition, glyphContours, depth);
-                            glyphInfos.push(glyphInfo);
-                            this.updatePlaneBounds(glyphInfo.bounds, planeBounds);
                         }
                     }
                 }
             }
-            const vertexArray = new Float32Array(vertices);
-            const normalArray = new Float32Array(normals);
-            const indexArray = new Uint32Array(indices);
+            // Slice to used lengths (avoid returning oversized buffers)
+            const vertexArray = vertexBuffer.slice(0, vertexPos);
+            const normalArray = normalBuffer.slice(0, normalPos);
+            const indexArray = indexBuffer.slice(0, indexPos);
             perfLogger.end('GlyphGeometryBuilder.buildInstancedGeometry');
             return {
                 vertices: vertexArray,
@@ -3880,16 +4128,20 @@
                 planeBounds
             };
         }
-        appendGeometry(vertices, normals, indices, data, position, offset) {
-            for (let j = 0; j < data.vertices.length; j += 3) {
-                vertices.push(data.vertices[j] + position.x, data.vertices[j + 1] + position.y, data.vertices[j + 2] + position.z);
-            }
-            for (let j = 0; j < data.normals.length; j++) {
-                normals.push(data.normals[j]);
-            }
-            for (let j = 0; j < data.indices.length; j++) {
-                indices.push(data.indices[j] + offset);
-            }
+        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) => {
+                const relX = (g.x ?? 0) - refX;
+                const relY = (g.y ?? 0) - refY;
+                return `${g.g}:${relX},${relY}`;
+            });
+            const ids = parts.join('|');
+            const roundedDepth = Math.round(depth * 1000) / 1000;
+            return `${this.cacheKeyPrefix}_${ids}_${roundedDepth}_${removeOverlaps}`;
         }
         createGlyphInfo(glyph, vertexStart, vertexCount, position, contours, depth) {
             return {
@@ -3912,10 +4164,13 @@
             };
         }
         getContoursForGlyph(glyphId) {
-            const cached = this.contourCache.get(glyphId);
+            const key = `${this.cacheKeyPrefix}_${glyphId}`;
+            const cached = this.contourCache.get(key);
             if (cached) {
                 return cached;
             }
+            // Rebind collector before draw operation
+            this.drawCallbacks.setCollector(this.collector);
             this.collector.reset();
             this.collector.beginGlyph(glyphId, 0);
             this.loadedFont.module.exports.hb_font_draw_glyph(this.loadedFont.font.ptr, glyphId, this.drawCallbacks.getDrawFuncsPtr(), 0);
@@ -3929,7 +4184,7 @@
                     max: { x: 0, y: 0 }
                 }
             };
-            this.contourCache.set(glyphId, contours);
+            this.contourCache.set(key, contours);
             return contours;
         }
         tessellateGlyphCluster(paths, depth, isCFF) {
@@ -3966,13 +4221,11 @@
             }
             const boundsMin = new Vec3(minX, minY, minZ);
             const boundsMax = new Vec3(maxX, maxY, maxZ);
-            const vertexCount = extrudedResult.vertices.length / 3;
-            const IndexArray = vertexCount < 65536 ? Uint16Array : Uint32Array;
             return {
                 geometry: processedGeometry,
-                vertices: new Float32Array(extrudedResult.vertices),
-                normals: new Float32Array(extrudedResult.normals),
-                indices: new IndexArray(extrudedResult.indices),
+                vertices: extrudedResult.vertices,
+                normals: extrudedResult.normals,
+                indices: extrudedResult.indices,
                 bounds: { min: boundsMin, max: boundsMax },
                 useCount: 1
             };
@@ -3988,15 +4241,22 @@
             return this.extrudeAndPackage(processedGeometry, depth);
         }
         updatePlaneBounds(glyphBounds, planeBounds) {
-            const planeBox = new Box3(new Vec3(planeBounds.min.x, planeBounds.min.y, planeBounds.min.z), new Vec3(planeBounds.max.x, planeBounds.max.y, planeBounds.max.z));
-            const glyphBox = new Box3(new Vec3(glyphBounds.min.x, glyphBounds.min.y, glyphBounds.min.z), new Vec3(glyphBounds.max.x, glyphBounds.max.y, glyphBounds.max.z));
-            planeBox.union(glyphBox);
-            planeBounds.min.x = planeBox.min.x;
-            planeBounds.min.y = planeBox.min.y;
-            planeBounds.min.z = planeBox.min.z;
-            planeBounds.max.x = planeBox.max.x;
-            planeBounds.max.y = planeBox.max.y;
-            planeBounds.max.z = planeBox.max.z;
+            const pMin = planeBounds.min;
+            const pMax = planeBounds.max;
+            const gMin = glyphBounds.min;
+            const gMax = glyphBounds.max;
+            if (gMin.x < pMin.x)
+                pMin.x = gMin.x;
+            if (gMin.y < pMin.y)
+                pMin.y = gMin.y;
+            if (gMin.z < pMin.z)
+                pMin.z = gMin.z;
+            if (gMax.x > pMax.x)
+                pMax.x = gMax.x;
+            if (gMax.y > pMax.y)
+                pMax.y = gMax.y;
+            if (gMax.z > pMax.z)
+                pMax.z = gMax.z;
         }
         getCacheStats() {
             return this.cache.getStats();
@@ -4004,6 +4264,8 @@
         clearCache() {
             this.cache.clear();
             this.wordCache.clear();
+            this.clusteringCache.clear();
+            this.contourCache.clear();
         }
     }
 
@@ -4018,12 +4280,17 @@
             perfLogger.start('TextShaper.shapeLines', {
                 lineCount: lineInfos.length
             });
-            const clustersByLine = [];
-            lineInfos.forEach((lineInfo, lineIndex) => {
-                const clusters = this.shapeLineIntoClusters(lineInfo, lineIndex, scaledLineHeight, letterSpacing, align, direction);
-                clustersByLine.push(clusters);
-            });
-            return clustersByLine;
+            try {
+                const clustersByLine = [];
+                lineInfos.forEach((lineInfo, lineIndex) => {
+                    const clusters = this.shapeLineIntoClusters(lineInfo, lineIndex, scaledLineHeight, letterSpacing, align, direction);
+                    clustersByLine.push(clusters);
+                });
+                return clustersByLine;
+            }
+            finally {
+                perfLogger.end('TextShaper.shapeLines');
+            }
         }
         shapeLineIntoClusters(lineInfo, lineIndex, scaledLineHeight, letterSpacing, align, direction) {
             const buffer = this.loadedFont.hb.createBuffer();
@@ -4171,162 +4438,6 @@
         }
     }
 
-    const DEFAULT_CACHE_SIZE_MB = 250;
-    class GlyphCache {
-        constructor(maxCacheSizeMB) {
-            this.cache = new Map();
-            this.head = null;
-            this.tail = null;
-            this.stats = {
-                hits: 0,
-                misses: 0,
-                totalGlyphs: 0,
-                uniqueGlyphs: 0,
-                cacheSize: 0,
-                saved: 0,
-                memoryUsage: 0
-            };
-            if (maxCacheSizeMB) {
-                this.maxCacheSize = maxCacheSizeMB * 1024 * 1024;
-            }
-        }
-        getCacheKey(fontId, glyphId, depth, removeOverlaps) {
-            // Round depth to avoid floating point precision issues
-            const roundedDepth = Math.round(depth * 1000) / 1000;
-            return `${fontId}_${glyphId}_${roundedDepth}_${removeOverlaps}`;
-        }
-        has(fontId, glyphId, depth, removeOverlaps) {
-            const key = this.getCacheKey(fontId, glyphId, depth, removeOverlaps);
-            return this.cache.has(key);
-        }
-        get(fontId, glyphId, depth, removeOverlaps) {
-            const key = this.getCacheKey(fontId, glyphId, depth, removeOverlaps);
-            const node = this.cache.get(key);
-            if (node) {
-                this.stats.hits++;
-                this.stats.saved++;
-                node.data.useCount++;
-                // Move to head (most recently used)
-                this.moveToHead(node);
-                this.stats.totalGlyphs++;
-                return node.data;
-            }
-            else {
-                this.stats.misses++;
-                this.stats.totalGlyphs++;
-                return undefined;
-            }
-        }
-        set(fontId, glyphId, depth, removeOverlaps, glyph) {
-            const key = this.getCacheKey(fontId, glyphId, depth, removeOverlaps);
-            const memoryUsage = this.calculateMemoryUsage(glyph);
-            // LRU eviction when memory limit exceeded
-            if (this.maxCacheSize &&
-                this.stats.memoryUsage + memoryUsage > this.maxCacheSize) {
-                this.evictLRU(memoryUsage);
-            }
-            const node = {
-                key,
-                data: glyph,
-                prev: null,
-                next: null
-            };
-            this.cache.set(key, node);
-            this.addToHead(node);
-            this.stats.uniqueGlyphs = this.cache.size;
-            this.stats.cacheSize++;
-            this.stats.memoryUsage += memoryUsage;
-        }
-        calculateMemoryUsage(glyph) {
-            let size = 0;
-            // 3 floats per vertex * 4 bytes per float
-            size += glyph.vertices.length * 4;
-            // 3 floats per normal * 4 bytes per float
-            size += glyph.normals.length * 4;
-            // Indices (Uint16Array or Uint32Array)
-            size += glyph.indices.length * glyph.indices.BYTES_PER_ELEMENT;
-            // Bounds (2 Vec3s = 6 floats * 4 bytes)
-            size += 24;
-            // Object overhead
-            size += 256;
-            return size;
-        }
-        // LRU eviction
-        evictLRU(requiredSpace) {
-            let freedSpace = 0;
-            while (this.tail && freedSpace < requiredSpace) {
-                const memoryUsage = this.calculateMemoryUsage(this.tail.data);
-                const nodeToRemove = this.tail;
-                this.removeTail();
-                this.cache.delete(nodeToRemove.key);
-                this.stats.memoryUsage -= memoryUsage;
-                this.stats.cacheSize--;
-                freedSpace += memoryUsage;
-            }
-        }
-        addToHead(node) {
-            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);
-            }
-        }
-        moveToHead(node) {
-            if (node === this.head)
-                return;
-            this.removeNode(node);
-            this.addToHead(node);
-        }
-        clear() {
-            this.cache.clear();
-            this.head = null;
-            this.tail = null;
-            this.stats = {
-                hits: 0,
-                misses: 0,
-                totalGlyphs: 0,
-                uniqueGlyphs: 0,
-                cacheSize: 0,
-                saved: 0,
-                memoryUsage: 0
-            };
-        }
-        getStats() {
-            const hitRate = this.stats.totalGlyphs > 0
-                ? (this.stats.hits / this.stats.totalGlyphs) * 100
-                : 0;
-            this.stats.uniqueGlyphs = this.cache.size;
-            return {
-                ...this.stats,
-                hitRate,
-                memoryUsageMB: this.stats.memoryUsage / (1024 * 1024)
-            };
-        }
-    }
-    const globalGlyphCache = new GlyphCache(DEFAULT_CACHE_SIZE_MB);
-
     var hb = {exports: {}};
 
     var fs = {}; const readFileSync = () => { throw new Error('fs not available in browser'); };
@@ -5032,14 +5143,25 @@
                     max: { x: 0, y: 0, z: 0 }
                 };
             }
-            const box = new Box3();
+            let minX = Infinity, minY = Infinity, minZ = Infinity;
+            let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
             for (const glyph of glyphs) {
-                const glyphBox = new Box3(new Vec3(glyph.bounds.min.x, glyph.bounds.min.y, glyph.bounds.min.z), new Vec3(glyph.bounds.max.x, glyph.bounds.max.y, glyph.bounds.max.z));
-                box.union(glyphBox);
+                if (glyph.bounds.min.x < minX)
+                    minX = glyph.bounds.min.x;
+                if (glyph.bounds.min.y < minY)
+                    minY = glyph.bounds.min.y;
+                if (glyph.bounds.min.z < minZ)
+                    minZ = glyph.bounds.min.z;
+                if (glyph.bounds.max.x > maxX)
+                    maxX = glyph.bounds.max.x;
+                if (glyph.bounds.max.y > maxY)
+                    maxY = glyph.bounds.max.y;
+                if (glyph.bounds.max.z > maxZ)
+                    maxZ = glyph.bounds.max.z;
             }
             return {
-                min: { x: box.min.x, y: box.min.y, z: box.min.z },
-                max: { x: box.max.x, y: box.max.y, z: box.max.z }
+                min: { x: minX, y: minY, z: minZ },
+                max: { x: maxX, y: maxY, z: maxZ }
             };
         }
     }
@@ -5049,8 +5171,16 @@
         static { this.patternCache = new Map(); }
         static { this.hbInitPromise = null; }
         static { this.fontCache = new Map(); }
+        static { this.fontCacheMemoryBytes = 0; }
+        static { this.maxFontCacheMemoryBytes = Infinity; }
         static { this.fontIdCounter = 0; }
-        constructor(config) {
+        // Stringify with sorted keys for cache stability
+        static stableStringify(obj) {
+            const keys = Object.keys(obj).sort();
+            const pairs = keys.map(k => `${k}:${obj[k]}`);
+            return pairs.join(',');
+        }
+        constructor() {
             this.currentFontId = '';
             if (!Text.hbInitPromise) {
                 Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
@@ -5081,7 +5211,7 @@
                 Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
             }
             const loadedFont = await Text.resolveFont(options);
-            const text = new Text({ maxCacheSizeMB: options.maxCacheSizeMB });
+            const text = new Text();
             text.setLoadedFont(loadedFont);
             // Initial creation
             const { font, maxCacheSizeMB, ...geometryOptions } = options;
@@ -5133,10 +5263,10 @@
                 : `buffer-${Text.generateFontContentHash(options.font)}`;
             let fontKey = baseFontKey;
             if (options.fontVariations) {
-                fontKey += `_var_${JSON.stringify(options.fontVariations)}`;
+                fontKey += `_var_${Text.stableStringify(options.fontVariations)}`;
             }
             if (options.fontFeatures) {
-                fontKey += `_feat_${JSON.stringify(options.fontFeatures)}`;
+                fontKey += `_feat_${Text.stableStringify(options.fontFeatures)}`;
             }
             let loadedFont = Text.fontCache.get(fontKey);
             if (!loadedFont) {
@@ -5149,17 +5279,53 @@
             await tempText.loadFont(font, fontVariations, fontFeatures);
             const loadedFont = tempText.getLoadedFont();
             Text.fontCache.set(fontKey, loadedFont);
+            Text.trackFontCacheAdd(loadedFont);
+            Text.enforceFontCacheMemoryLimit();
             return loadedFont;
         }
+        static trackFontCacheAdd(loadedFont) {
+            const size = loadedFont._buffer?.byteLength ?? 0;
+            Text.fontCacheMemoryBytes += size;
+        }
+        static trackFontCacheRemove(fontKey) {
+            const font = Text.fontCache.get(fontKey);
+            if (!font)
+                return;
+            const size = font._buffer?.byteLength ?? 0;
+            Text.fontCacheMemoryBytes -= size;
+            if (Text.fontCacheMemoryBytes < 0)
+                Text.fontCacheMemoryBytes = 0;
+        }
+        static enforceFontCacheMemoryLimit() {
+            if (Text.maxFontCacheMemoryBytes === Infinity)
+                return;
+            while (Text.fontCacheMemoryBytes > Text.maxFontCacheMemoryBytes &&
+                Text.fontCache.size > 0) {
+                const firstKey = Text.fontCache.keys().next().value;
+                if (firstKey === undefined)
+                    break;
+                Text.trackFontCacheRemove(firstKey);
+                Text.fontCache.delete(firstKey);
+            }
+        }
         static generateFontContentHash(buffer) {
             if (buffer) {
-                // Hash of first and last bytes plus length for uniqueness
+                // FNV-1a hash sampling 32 points
                 const view = new Uint8Array(buffer);
-                return `${view[0]}_${view[Math.floor(view.length / 2)]}_${view[view.length - 1]}_${view.length}`;
+                let hash = 2166136261;
+                const samplePoints = Math.min(32, view.length);
+                const step = Math.floor(view.length / samplePoints);
+                for (let i = 0; i < samplePoints; i++) {
+                    const index = i * step;
+                    hash ^= view[index];
+                    hash = Math.imul(hash, 16777619);
+                }
+                hash ^= view.length;
+                hash = Math.imul(hash, 16777619);
+                return (hash >>> 0).toString(36);
             }
             else {
-                // Fallback to counter if no buffer available
-                return `${++Text.fontIdCounter}`;
+                return `c${++Text.fontIdCounter}`;
             }
         }
         setLoadedFont(loadedFont) {
@@ -5167,10 +5333,10 @@
             const contentHash = Text.generateFontContentHash(loadedFont._buffer);
             this.currentFontId = `font_${contentHash}`;
             if (loadedFont.fontVariations) {
-                this.currentFontId += `_var_${JSON.stringify(loadedFont.fontVariations)}`;
+                this.currentFontId += `_var_${Text.stableStringify(loadedFont.fontVariations)}`;
             }
             if (loadedFont.fontFeatures) {
-                this.currentFontId += `_feat_${JSON.stringify(loadedFont.fontFeatures)}`;
+                this.currentFontId += `_feat_${Text.stableStringify(loadedFont.fontFeatures)}`;
             }
         }
         async loadFont(fontSrc, fontVariations, fontFeatures) {
@@ -5200,10 +5366,10 @@
                 const contentHash = Text.generateFontContentHash(fontBuffer);
                 this.currentFontId = `font_${contentHash}`;
                 if (fontVariations) {
-                    this.currentFontId += `_var_${JSON.stringify(fontVariations)}`;
+                    this.currentFontId += `_var_${Text.stableStringify(fontVariations)}`;
                 }
                 if (fontFeatures) {
-                    this.currentFontId += `_feat_${JSON.stringify(fontFeatures)}`;
+                    this.currentFontId += `_feat_${Text.stableStringify(fontFeatures)}`;
                 }
             }
             catch (error) {
@@ -5231,7 +5397,7 @@
                 this.updateFontVariations(options);
                 if (!this.geometryBuilder) {
                     const cache = options.maxCacheSizeMB
-                        ? new GlyphCache(options.maxCacheSizeMB)
+                        ? createGlyphCache(options.maxCacheSizeMB)
                         : globalGlyphCache;
                     this.geometryBuilder = new GlyphGeometryBuilder(cache, this.loadedFont);
                     this.geometryBuilder.setFontId(this.currentFontId);
@@ -5334,8 +5500,8 @@
         }
         updateFontVariations(options) {
             if (options.fontVariations && this.loadedFont) {
-                if (JSON.stringify(options.fontVariations) !==
-                    JSON.stringify(this.loadedFont.fontVariations)) {
+                if (Text.stableStringify(options.fontVariations) !==
+                    Text.stableStringify(this.loadedFont.fontVariations || {})) {
                     this.loadedFont.font.setVariations(options.fontVariations);
                     this.loadedFont.fontVariations = options.fontVariations;
                 }
@@ -5351,7 +5517,12 @@
             if (width !== undefined) {
                 widthInFontUnits = width * (this.loadedFont.upem / size);
             }
-            const depthInFontUnits = depth * (this.loadedFont.upem / size);
+            // 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;
+            const minExtrudeDepth = this.loadedFont.upem * 0.000025;
+            const depthInFontUnits = rawDepthInFontUnits <= 0 ? 0 : Math.max(rawDepthInFontUnits, minExtrudeDepth);
             if (!this.textLayout) {
                 this.textLayout = new TextLayout(this.loadedFont);
             }
@@ -5583,6 +5754,15 @@
         static registerPattern(language, pattern) {
             Text.patternCache.set(language, pattern);
         }
+        static clearFontCache() {
+            Text.fontCache.clear();
+            Text.fontCacheMemoryBytes = 0;
+        }
+        static setMaxFontCacheMemoryMB(limitMB) {
+            Text.maxFontCacheMemoryBytes =
+                limitMB === Infinity ? Infinity : Math.max(1, Math.floor(limitMB)) * 1024 * 1024;
+            Text.enforceFontCacheMemoryLimit();
+        }
         getLoadedFont() {
             return this.loadedFont;
         }
@@ -5655,6 +5835,7 @@
     exports.DEFAULT_CURVE_FIDELITY = DEFAULT_CURVE_FIDELITY;
     exports.FontMetadataExtractor = FontMetadataExtractor;
     exports.Text = Text;
+    exports.createGlyphCache = createGlyphCache;
     exports.globalGlyphCache = globalGlyphCache;
 
 }));