three-text 0.2.12 → 0.2.14

package/dist/index.cjs

@@ -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
@@ -48,7 +48,9 @@ class PerformanceLogger {
         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,
@@ -60,17 +62,26 @@ class PerformanceLogger {
         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;
@@ -713,7 +724,7 @@ class LineBreak {
             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');
@@ -775,7 +786,11 @@ class LineBreak {
             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);
@@ -1083,7 +1098,7 @@ class LineBreak {
             }
         }
     }
-    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;
@@ -1126,6 +1141,12 @@ class LineBreak {
                     ? 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) {
@@ -1288,6 +1309,10 @@ class LineBreak {
                 }
             }
             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;
@@ -1341,6 +1366,10 @@ class LineBreak {
                 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') {
@@ -1402,9 +1431,6 @@ function convertFontFeaturesToString(features) {
 }
 
 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);
@@ -1413,7 +1439,6 @@ class TextMeasurer {
         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;
@@ -1460,6 +1485,7 @@ class TextLayout {
                 disableShortLineDetection,
                 shortLineThreshold,
                 unitsPerEm: this.loadedFont.upem,
+                letterSpacing,
                 measureText: (textToMeasure) => TextMeasurer.measureTextWidth(this.loadedFont, textToMeasure, letterSpacing // Letter spacing included in width measurements
                 )
             });
@@ -1470,10 +1496,11 @@ class TextLayout {
             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;
@@ -1512,7 +1539,6 @@ class TextLayout {
 // 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
@@ -1527,6 +1553,28 @@ const TABLE_TAG_CFF2 = 0x43464632; // 'CFF2'
 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) {
@@ -1536,45 +1584,19 @@ class FontMetadataExtractor {
         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;
@@ -1617,23 +1639,10 @@ class FontMetadataExtractor {
     }
     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 {
@@ -1864,6 +1873,7 @@ class WoffConverter {
         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
@@ -1946,11 +1956,10 @@ class FontLoader {
         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 {
@@ -1987,7 +1996,8 @@ class FontLoader {
                 isVariable,
                 variationAxes,
                 availableFeatures: featureData?.tags,
-                featureNames: featureData?.names
+                featureNames: featureData?.names,
+                _buffer: fontBuffer // For stable font ID generation
             };
         }
         catch (error) {
@@ -2017,7 +2027,91 @@ class FontLoader {
     }
 }
 
+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).`);
+    }
     {
         // In ESM build, use dynamic imports
         try {
@@ -2206,108 +2300,233 @@ class Vec3 {
         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) {
@@ -2564,69 +2783,137 @@ class Tessellator {
 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 };
     }
 }
 
@@ -2637,18 +2924,21 @@ class BoundaryClusterer {
         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;
@@ -2668,7 +2958,6 @@ class BoundaryClusterer {
             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;
             }
@@ -2684,8 +2973,6 @@ class BoundaryClusterer {
         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 &&
@@ -2702,10 +2989,12 @@ class BoundaryClusterer {
         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());
     }
@@ -2937,13 +3226,17 @@ class PathOptimizer {
             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 {
@@ -3063,9 +3356,13 @@ class Polygonizer {
                 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;
@@ -3160,9 +3457,12 @@ class Polygonizer {
                     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);
@@ -3182,9 +3482,12 @@ class Polygonizer {
                     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);
@@ -3204,12 +3507,18 @@ class Polygonizer {
                     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);
@@ -3471,6 +3780,9 @@ class DrawCallbackHandler {
             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');
@@ -3547,229 +3859,73 @@ class DrawCallbackHandler {
         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) {
@@ -3779,9 +3935,58 @@ class GlyphGeometryBuilder {
             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 },
@@ -3790,83 +3995,126 @@ class GlyphGeometryBuilder {
         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,
@@ -3876,16 +4124,20 @@ class GlyphGeometryBuilder {
             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 {
@@ -3908,10 +4160,13 @@ class GlyphGeometryBuilder {
         };
     }
     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);
@@ -3925,7 +4180,7 @@ class GlyphGeometryBuilder {
                 max: { x: 0, y: 0 }
             }
         };
-        this.contourCache.set(glyphId, contours);
+        this.contourCache.set(key, contours);
         return contours;
     }
     tessellateGlyphCluster(paths, depth, isCFF) {
@@ -3962,13 +4217,11 @@ class GlyphGeometryBuilder {
         }
         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
         };
@@ -3984,15 +4237,22 @@ class GlyphGeometryBuilder {
         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();
@@ -4000,6 +4260,8 @@ class GlyphGeometryBuilder {
     clearCache() {
         this.cache.clear();
         this.wordCache.clear();
+        this.clusteringCache.clear();
+        this.contourCache.clear();
     }
 }
 
@@ -4014,12 +4276,17 @@ class TextShaper {
         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();
@@ -4167,162 +4434,6 @@ class TextShaper {
     }
 }
 
-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'); };
@@ -5028,14 +5139,25 @@ class TextRangeQuery {
                 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 }
         };
     }
 }
@@ -5045,8 +5167,16 @@ class Text {
     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();
@@ -5077,7 +5207,7 @@ class Text {
             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;
@@ -5129,10 +5259,10 @@ class Text {
             : `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) {
@@ -5145,17 +5275,53 @@ class Text {
         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) {
@@ -5163,10 +5329,10 @@ class Text {
         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) {
@@ -5196,10 +5362,10 @@ class Text {
             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) {
@@ -5227,7 +5393,7 @@ class Text {
             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);
@@ -5330,8 +5496,8 @@ class Text {
     }
     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;
             }
@@ -5347,7 +5513,12 @@ class Text {
         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);
         }
@@ -5579,6 +5750,15 @@ class Text {
     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;
     }
@@ -5651,4 +5831,5 @@ class Text {
 exports.DEFAULT_CURVE_FIDELITY = DEFAULT_CURVE_FIDELITY;
 exports.FontMetadataExtractor = FontMetadataExtractor;
 exports.Text = Text;
+exports.createGlyphCache = createGlyphCache;
 exports.globalGlyphCache = globalGlyphCache;