three-text 0.2.12 → 0.2.14

package/dist/three/react.cjs

@@ -31,12 +31,24 @@ function deepEqual(a, b) {
         return false;
     if (typeof a !== 'object' || typeof b !== 'object')
         return false;
+    // Arrays (common in options like color, byCharRange, etc.)
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b))
+            return false;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
     const keysA = Object.keys(a);
     const keysB = Object.keys(b);
     if (keysA.length !== keysB.length)
         return false;
     for (const key of keysA) {
-        if (!keysB.includes(key))
+        if (!Object.prototype.hasOwnProperty.call(b, key))
             return false;
         if (!deepEqual(a[key], b[key]))
             return false;
@@ -54,10 +66,14 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
     const { children, font, material, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1], onLoad, onError, vertexColors = true, ...restOptions } = props;
     const [geometry, setGeometry] = react.useState(null);
     const [error, setError] = react.useState(null);
-    const defaultMaterial = react.useMemo(() => new THREE__namespace.MeshBasicMaterial({
-        color: 0xffffff,
-        side: THREE__namespace.DoubleSide,
-    }), []);
+    const geometryRef = react.useRef(null);
+    const defaultMaterial = react.useMemo(() => {
+        return new THREE__namespace.MeshBasicMaterial({
+            color: 0xffffff,
+            side: THREE__namespace.DoubleSide,
+            vertexColors
+        });
+    }, [vertexColors]);
     const finalMaterial = material || defaultMaterial;
     const memoizedTextOptions = useDeepCompareMemo(restOptions);
     react.useEffect(() => {
@@ -70,13 +86,19 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
                 const text = await index.Text.create({
                     text: children,
                     font,
-                    ...memoizedTextOptions,
+                    ...memoizedTextOptions
                 });
-                if (!cancelled) {
-                    setGeometry(text.geometry);
-                    if (onLoad)
-                        onLoad(text.geometry, text);
+                if (cancelled) {
+                    // If a newer render superseded this request, avoid leaking geometry
+                    text.geometry.dispose();
+                    return;
                 }
+                // Dispose previous geometry (if any) before swapping
+                geometryRef.current?.dispose();
+                geometryRef.current = text.geometry;
+                setGeometry(text.geometry);
+                if (onLoad)
+                    onLoad(text.geometry, text);
             }
             catch (err) {
                 const error = err;
@@ -85,7 +107,7 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
                     if (onError)
                         onError(error);
                     else
-                        console.error("ThreeText error:", error);
+                        console.error('ThreeText error:', error);
                 }
             }
         }
@@ -93,18 +115,20 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
         return () => {
             cancelled = true;
         };
-    }, [font, children, memoizedTextOptions, onLoad, onError, vertexColors]);
-    // Handle geometry and material cleanup
+    }, [font, children, memoizedTextOptions, onLoad, onError]);
+    // Cleanup geometry on unmount
     react.useEffect(() => {
         return () => {
-            if (geometry) {
-                geometry.dispose();
-            }
-            if (!material && defaultMaterial) {
-                defaultMaterial.dispose();
-            }
+            geometryRef.current?.dispose();
+            geometryRef.current = null;
+        };
+    }, []);
+    // Cleanup default material when it changes or on unmount
+    react.useEffect(() => {
+        return () => {
+            defaultMaterial.dispose();
         };
-    }, [geometry, material, defaultMaterial]);
+    }, [defaultMaterial]);
     if (error || !geometry) {
         return null;
     }

package/dist/three/react.d.ts

@@ -2,6 +2,13 @@ import * as react from 'react';
 import * as THREE from 'three';
 import { TextOptions as TextOptions$1, ThreeTextGeometryInfo, Text as Text$2 } from './index';
 
+interface HyphenationTrieNode {
+    patterns: number[] | null;
+    children: {
+        [char: string]: HyphenationTrieNode;
+    };
+}
+
 interface BoundingBox {
     min: {
         x: number;
@@ -15,13 +22,6 @@ interface BoundingBox {
     };
 }
 
-interface HyphenationTrieNode {
-    patterns: number[] | null;
-    children: {
-        [char: string]: HyphenationTrieNode;
-    };
-}
-
 type TextAlign = 'left' | 'center' | 'right' | 'justify';
 type TextDirection = 'ltr' | 'rtl';
 interface LoadedFont {
@@ -187,6 +187,13 @@ interface TextGeometryInfo {
     query(options: TextQueryOptions): TextRange[];
     coloredRanges?: ColoredRange[];
 }
+interface TextHandle extends TextGeometryInfo {
+    getLoadedFont(): LoadedFont | undefined;
+    getCacheStatistics(): any;
+    clearCache(): void;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions>): Promise<TextHandle>;
+}
 interface ColorByRange {
     start: number;
     end: number;
@@ -279,16 +286,6 @@ interface LayoutOptions {
     shortLineThreshold?: number;
 }
 
-interface GlyphCacheStats {
-    hits: number;
-    misses: number;
-    totalGlyphs: number;
-    uniqueGlyphs: number;
-    cacheSize: number;
-    saved: number;
-    memoryUsage: number;
-}
-
 declare global {
     interface Window {
         hbjs?: any;
@@ -299,7 +296,10 @@ declare class Text$1 {
     private static patternCache;
     private static hbInitPromise;
     private static fontCache;
+    private static fontCacheMemoryBytes;
+    private static maxFontCacheMemoryBytes;
     private static fontIdCounter;
+    private static stableStringify;
     private fontLoader;
     private loadedFont?;
     private currentFontId;
@@ -310,13 +310,12 @@ declare class Text$1 {
     static setHarfBuzzPath(path: string): void;
     static setHarfBuzzBuffer(wasmBuffer: ArrayBuffer): void;
     static init(): Promise<HarfBuzzInstance>;
-    static create(options: TextOptions): Promise<TextGeometryInfo & Pick<Text$1, 'getLoadedFont' | 'getCacheStatistics' | 'clearCache' | 'measureTextWidth'> & {
-        update: (options: Partial<TextOptions>) => Promise<TextGeometryInfo & Pick<Text$1, 'getLoadedFont' | 'getCacheStatistics' | 'clearCache' | 'measureTextWidth'> & {
-            update: (options: Partial<TextOptions>) => Promise<any>;
-        }>;
-    }>;
+    static create(options: TextOptions): Promise<TextHandle>;
     private static resolveFont;
     private static loadAndCacheFont;
+    private static trackFontCacheAdd;
+    private static trackFontCacheRemove;
+    private static enforceFontCacheMemoryLimit;
     private static generateFontContentHash;
     private setLoadedFont;
     private loadFont;
@@ -330,16 +329,29 @@ declare class Text$1 {
     getFontMetrics(): FontMetrics;
     static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
     static registerPattern(language: string, pattern: HyphenationTrieNode): void;
+    static clearFontCache(): void;
+    static setMaxFontCacheMemoryMB(limitMB: number): void;
     getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
-    getCacheStatistics(): GlyphCacheStats | null;
+    getCacheStatistics(): (CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    }) | null;
     clearCache(): void;
     private createGlyphAttributes;
     private resetHelpers;
     destroy(): void;
 }
 
-interface ThreeTextProps extends Omit<TextOptions$1, "text"> {
+interface CacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    size: number;
+    memoryUsage: number;
+}
+
+interface ThreeTextProps extends Omit<TextOptions$1, 'text'> {
     children: string;
     font: string | ArrayBuffer;
     material?: THREE.Material;

package/dist/three/react.js

@@ -1,5 +1,5 @@
 import { jsx } from 'react/jsx-runtime';
-import { forwardRef, useState, useMemo, useEffect, useRef } from 'react';
+import { forwardRef, useState, useRef, useMemo, useEffect } from 'react';
 import * as THREE from 'three';
 import { Text as Text$2 } from './index';
 
@@ -10,12 +10,24 @@ function deepEqual(a, b) {
         return false;
     if (typeof a !== 'object' || typeof b !== 'object')
         return false;
+    // Arrays (common in options like color, byCharRange, etc.)
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b))
+            return false;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
     const keysA = Object.keys(a);
     const keysB = Object.keys(b);
     if (keysA.length !== keysB.length)
         return false;
     for (const key of keysA) {
-        if (!keysB.includes(key))
+        if (!Object.prototype.hasOwnProperty.call(b, key))
             return false;
         if (!deepEqual(a[key], b[key]))
             return false;
@@ -33,10 +45,14 @@ const Text$1 = forwardRef(function Text(props, ref) {
     const { children, font, material, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1], onLoad, onError, vertexColors = true, ...restOptions } = props;
     const [geometry, setGeometry] = useState(null);
     const [error, setError] = useState(null);
-    const defaultMaterial = useMemo(() => new THREE.MeshBasicMaterial({
-        color: 0xffffff,
-        side: THREE.DoubleSide,
-    }), []);
+    const geometryRef = useRef(null);
+    const defaultMaterial = useMemo(() => {
+        return new THREE.MeshBasicMaterial({
+            color: 0xffffff,
+            side: THREE.DoubleSide,
+            vertexColors
+        });
+    }, [vertexColors]);
     const finalMaterial = material || defaultMaterial;
     const memoizedTextOptions = useDeepCompareMemo(restOptions);
     useEffect(() => {
@@ -49,13 +65,19 @@ const Text$1 = forwardRef(function Text(props, ref) {
                 const text = await Text$2.create({
                     text: children,
                     font,
-                    ...memoizedTextOptions,
+                    ...memoizedTextOptions
                 });
-                if (!cancelled) {
-                    setGeometry(text.geometry);
-                    if (onLoad)
-                        onLoad(text.geometry, text);
+                if (cancelled) {
+                    // If a newer render superseded this request, avoid leaking geometry
+                    text.geometry.dispose();
+                    return;
                 }
+                // Dispose previous geometry (if any) before swapping
+                geometryRef.current?.dispose();
+                geometryRef.current = text.geometry;
+                setGeometry(text.geometry);
+                if (onLoad)
+                    onLoad(text.geometry, text);
             }
             catch (err) {
                 const error = err;
@@ -64,7 +86,7 @@ const Text$1 = forwardRef(function Text(props, ref) {
                     if (onError)
                         onError(error);
                     else
-                        console.error("ThreeText error:", error);
+                        console.error('ThreeText error:', error);
                 }
             }
         }
@@ -72,18 +94,20 @@ const Text$1 = forwardRef(function Text(props, ref) {
         return () => {
             cancelled = true;
         };
-    }, [font, children, memoizedTextOptions, onLoad, onError, vertexColors]);
-    // Handle geometry and material cleanup
+    }, [font, children, memoizedTextOptions, onLoad, onError]);
+    // Cleanup geometry on unmount
     useEffect(() => {
         return () => {
-            if (geometry) {
-                geometry.dispose();
-            }
-            if (!material && defaultMaterial) {
-                defaultMaterial.dispose();
-            }
+            geometryRef.current?.dispose();
+            geometryRef.current = null;
+        };
+    }, []);
+    // Cleanup default material when it changes or on unmount
+    useEffect(() => {
+        return () => {
+            defaultMaterial.dispose();
         };
-    }, [geometry, material, defaultMaterial]);
+    }, [defaultMaterial]);
     if (error || !geometry) {
         return null;
     }

package/dist/types/core/Text.d.ts

@@ -1,4 +1,4 @@
-import type { TextOptions, TextGeometryInfo, FontMetrics, LoadedFont, HarfBuzzInstance } from './types';
+import type { TextOptions, TextHandle, FontMetrics, LoadedFont, HarfBuzzInstance } from './types';
 import type { HyphenationTrieNode } from '../hyphenation';
 declare global {
     interface Window {
@@ -10,7 +10,10 @@ export declare class Text {
     private static patternCache;
     private static hbInitPromise;
     private static fontCache;
+    private static fontCacheMemoryBytes;
+    private static maxFontCacheMemoryBytes;
     private static fontIdCounter;
+    private static stableStringify;
     private fontLoader;
     private loadedFont?;
     private currentFontId;
@@ -21,13 +24,12 @@ export declare class Text {
     static setHarfBuzzPath(path: string): void;
     static setHarfBuzzBuffer(wasmBuffer: ArrayBuffer): void;
     static init(): Promise<HarfBuzzInstance>;
-    static create(options: TextOptions): Promise<TextGeometryInfo & Pick<Text, 'getLoadedFont' | 'getCacheStatistics' | 'clearCache' | 'measureTextWidth'> & {
-        update: (options: Partial<TextOptions>) => Promise<TextGeometryInfo & Pick<Text, 'getLoadedFont' | 'getCacheStatistics' | 'clearCache' | 'measureTextWidth'> & {
-            update: (options: Partial<TextOptions>) => Promise<any>;
-        }>;
-    }>;
+    static create(options: TextOptions): Promise<TextHandle>;
     private static resolveFont;
     private static loadAndCacheFont;
+    private static trackFontCacheAdd;
+    private static trackFontCacheRemove;
+    private static enforceFontCacheMemoryLimit;
     private static generateFontContentHash;
     private setLoadedFont;
     private loadFont;
@@ -41,9 +43,14 @@ export declare class Text {
     getFontMetrics(): FontMetrics;
     static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
     static registerPattern(language: string, pattern: HyphenationTrieNode): void;
+    static clearFontCache(): void;
+    static setMaxFontCacheMemoryMB(limitMB: number): void;
     getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
-    getCacheStatistics(): import("./cache/GlyphCache").GlyphCacheStats | null;
+    getCacheStatistics(): (import("..").CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    }) | null;
     clearCache(): void;
     private createGlyphAttributes;
     private resetHelpers;

package/dist/types/core/cache/GlyphGeometryBuilder.d.ts

@@ -1,6 +1,6 @@
-import { GlyphCache } from './GlyphCache';
-import { GlyphGeometryInfo, LoadedFont, GlyphCluster } from '../types';
+import { GlyphGeometryInfo, LoadedFont, GlyphCluster, GlyphData } from '../types';
 import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
+import { LRUCache } from '../../utils/LRUCache';
 export interface InstancedTextGeometry {
     vertices: Float32Array;
     normals: Float32Array;
@@ -24,25 +24,34 @@ export declare class GlyphGeometryBuilder {
     private tessellator;
     private extruder;
     private fontId;
+    private cacheKeyPrefix;
+    private curveFidelityConfig?;
+    private geometryOptimizationOptions?;
     private clusterer;
     private collector;
     private drawCallbacks;
     private loadedFont;
     private wordCache;
     private contourCache;
-    constructor(cache: GlyphCache, loadedFont: LoadedFont);
+    private clusteringCache;
+    constructor(cache: LRUCache<string, GlyphData>, loadedFont: LoadedFont);
     getOptimizationStats(): import("../geometry/PathOptimizer").OptimizationStats;
     setCurveFidelityConfig(config?: CurveFidelityConfig): void;
     setGeometryOptimization(options?: GeometryOptimizationOptions): void;
     setFontId(fontId: string): void;
+    private updateCacheKeyPrefix;
+    private getGeometryConfigSignature;
     buildInstancedGeometry(clustersByLine: GlyphCluster[][], depth: number, removeOverlaps: boolean, isCFF: boolean, separateGlyphs?: boolean, coloredTextIndices?: Set<number>): InstancedTextGeometry;
-    private appendGeometry;
+    private getClusterKey;
     private createGlyphInfo;
     private getContoursForGlyph;
     private tessellateGlyphCluster;
     private extrudeAndPackage;
     private tessellateGlyph;
     private updatePlaneBounds;
-    getCacheStats(): import("./GlyphCache").GlyphCacheStats;
+    getCacheStats(): import("../../utils/LRUCache").CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    };
     clearCache(): void;
 }

package/dist/types/core/cache/sharedCaches.d.ts

@@ -0,0 +1,12 @@
+import { LRUCache } from '../../utils/LRUCache';
+import type { GlyphData, GlyphContours } from '../types';
+export declare function getGlyphCacheKey(fontId: string, glyphId: number, depth: number, removeOverlaps: boolean): string;
+export declare function calculateGlyphMemoryUsage(glyph: GlyphData): number;
+export declare const globalGlyphCache: LRUCache<string, GlyphData>;
+export declare function createGlyphCache(maxCacheSizeMB?: number): LRUCache<string, GlyphData>;
+export declare const globalContourCache: LRUCache<string, GlyphContours>;
+export declare const globalWordCache: LRUCache<string, GlyphData>;
+export declare const globalClusteringCache: LRUCache<string, {
+    glyphIds: number[];
+    groups: number[][];
+}>;

package/dist/types/core/font/TableDirectory.d.ts

@@ -0,0 +1,7 @@
+export interface TableDirectoryEntry {
+    tag: number;
+    checksum: number;
+    offset: number;
+    length: number;
+}
+export declare function parseTableDirectory(view: DataView): Map<number, TableDirectoryEntry>;

package/dist/types/core/font/constants.d.ts

@@ -1,6 +1,5 @@
 export declare const FONT_SIGNATURE_TRUE_TYPE = 65536;
 export declare const FONT_SIGNATURE_OPEN_TYPE_CFF = 1330926671;
-export declare const FONT_SIGNATURE_TRUE_TYPE_COLLECTION = 1953784678;
 export declare const FONT_SIGNATURE_WOFF = 2001684038;
 export declare const FONT_SIGNATURE_WOFF2 = 2001684018;
 export declare const TABLE_TAG_HEAD = 1751474532;

package/dist/types/core/geometry/Extruder.d.ts

@@ -1,13 +1,10 @@
 import type { ProcessedGeometry } from '../types';
 export interface ExtrusionResult {
-    vertices: number[];
-    normals: number[];
-    indices: number[];
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
 }
 export declare class Extruder {
     constructor();
     extrude(geometry: ProcessedGeometry, depth: number | undefined, unitsPerEm: number): ExtrusionResult;
-    private addFlatFaces;
-    private addFrontAndBackFaces;
-    private addSideWalls;
 }

package/dist/types/core/layout/LineBreak.d.ts

@@ -50,6 +50,7 @@ export interface LineBreakOptions {
     respectExistingBreaks?: boolean;
     hyphenationPatterns?: HyphenationPatternsMap;
     unitsPerEm?: number;
+    letterSpacing?: number;
     tolerance?: number;
     pretolerance?: number;
     emergencyStretch?: number;
@@ -73,6 +74,7 @@ interface LineBreakContext {
     exHyphenPenalty: number;
     currentAlign: TextAlign;
     unitsPerEm?: number;
+    letterSpacingFU?: number;
 }
 export declare class LineBreak {
     private static badness;

package/dist/types/core/shaping/DrawCallbacks.d.ts

@@ -11,7 +11,9 @@ export declare class DrawCallbackHandler {
     private position;
     setPosition(x: number, y: number): void;
     updatePosition(dx: number, dy: number): void;
+    setCollector(collector: GlyphContourCollector): void;
     createDrawFuncs(font: LoadedFont, collector: GlyphContourCollector): void;
     getDrawFuncsPtr(): number;
     destroy(font: LoadedFont): void;
 }
+export declare function getSharedDrawCallbackHandler(font: LoadedFont): DrawCallbackHandler;

package/dist/types/core/shaping/TextShaper.d.ts

@@ -31,5 +31,8 @@ export declare class TextShaper {
     private calculateSpaceAdjustment;
     private calculateCJKAdjustment;
     clearCache(): void;
-    getCacheStats(): import("../..").GlyphCacheStats;
+    getCacheStats(): import("../..").CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    };
 }

package/dist/types/core/types.d.ts

@@ -163,6 +163,25 @@ export interface ProcessedGeometry {
     triangles: Triangles;
     contours: number[][];
 }
+export interface GlyphData {
+    geometry: ProcessedGeometry;
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    useCount: number;
+}
 export interface PathInfo {
     start: number;
     count: number;
@@ -234,6 +253,13 @@ export interface TextGeometryInfo {
     query(options: TextQueryOptions): TextRange[];
     coloredRanges?: ColoredRange[];
 }
+export interface TextHandle extends TextGeometryInfo {
+    getLoadedFont(): LoadedFont | undefined;
+    getCacheStatistics(): any;
+    clearCache(): void;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions>): Promise<TextHandle>;
+}
 export interface ColorByRange {
     start: number;
     end: number;

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 export { Text } from './core/Text';
 export { DEFAULT_CURVE_FIDELITY } from './core/geometry/Polygonizer';
 export { FontMetadataExtractor } from './core/font/FontMetadata';
-export { globalGlyphCache } from './core/cache/GlyphCache';
-export type { GlyphCache, GlyphCacheStats, GlyphData } from './core/cache/GlyphCache';
-export type { TextAlign, TextDirection, LineInfo, LoadedFont, HarfBuzzModule, HarfBuzzAPI, HarfBuzzBlob, HarfBuzzFace, HarfBuzzFont, HarfBuzzBuffer, HarfBuzzInstance, VariationAxis, ExtractedMetrics, VerticalMetrics, FontMetrics, ProcessedGeometry, Triangles, GlyphGeometryInfo, TextGeometryInfo, TextOptions, ColorOptions, ColorByRange, ColoredRange, PathInfo, HyphenationPatternsMap, CurveFidelityConfig, LayoutOptions, GeometryOptimizationOptions, TextRange, TextQueryOptions } from './core/types';
+export { globalGlyphCache, createGlyphCache } from './core/cache/sharedCaches';
+export type { CacheStats } from './utils/LRUCache';
+export type { TextAlign, TextDirection, LineInfo, LoadedFont, HarfBuzzModule, HarfBuzzAPI, HarfBuzzBlob, HarfBuzzFace, HarfBuzzFont, HarfBuzzBuffer, HarfBuzzInstance, VariationAxis, ExtractedMetrics, VerticalMetrics, FontMetrics, ProcessedGeometry, Triangles, GlyphData, GlyphGeometryInfo, TextGeometryInfo, TextHandle, TextOptions, ColorOptions, ColorByRange, ColoredRange, PathInfo, HyphenationPatternsMap, CurveFidelityConfig, LayoutOptions, GeometryOptimizationOptions, TextRange, TextQueryOptions } from './core/types';
 export type { HyphenationTrieNode } from './hyphenation';

package/dist/types/three/ThreeText.d.ts

@@ -1,6 +1,6 @@
-import * as THREE from "three";
-import type { TextOptions, ThreeTextGeometryInfo as TextGeometryInfo } from "./index";
-export interface ThreeTextProps extends Omit<TextOptions, "text"> {
+import * as THREE from 'three';
+import type { TextOptions, ThreeTextGeometryInfo as TextGeometryInfo } from './index';
+export interface ThreeTextProps extends Omit<TextOptions, 'text'> {
     children: string;
     font: string | ArrayBuffer;
     material?: THREE.Material;

package/dist/types/utils/LRUCache.d.ts

@@ -4,7 +4,7 @@ export interface LRUCacheOptions<K, V> {
     calculateSize?: (value: V) => number;
     onEvict?: (key: K, value: V) => void;
 }
-export interface LRUCacheStats {
+export interface CacheStats {
     hits: number;
     misses: number;
     evictions: number;
@@ -23,7 +23,7 @@ export declare class LRUCache<K, V> {
     set(key: K, value: V): void;
     delete(key: K): boolean;
     clear(): void;
-    getStats(): LRUCacheStats & {
+    getStats(): CacheStats & {
         hitRate: number;
         memoryUsageMB: number;
     };

package/dist/types/webgpu/index.d.ts

@@ -9,8 +9,7 @@ export interface WebGPUBufferSet {
         vertex: GPUVertexBufferLayout;
         color?: GPUVertexBufferLayout;
     };
-    indexFormat: GPUIndexFormat;
-    vertexCount: number;
+    indexCount: number;
     dispose(): void;
 }
 export declare function createWebGPUBuffers(device: GPUDevice, textGeometry: TextGeometryInfo): WebGPUBufferSet;

package/dist/webgpu/index.cjs

@@ -3,7 +3,7 @@
 // WebGPU adapter - lightweight utility to create GPU buffers from core geometry
 function createWebGPUBuffers(device, textGeometry) {
     const { vertices, normals, indices, colors } = textGeometry;
-    const vertexCount = indices.length;
+    const indexCount = indices.length;
     // Interleave position and normal data for better cache coherency
     // Layout: [px, py, pz, nx, ny, nz, px, py, pz, nx, ny, nz, ...]
     const interleavedData = new Float32Array((vertices.length / 3) * 6);
@@ -27,7 +27,7 @@ function createWebGPUBuffers(device, textGeometry) {
     });
     new Float32Array(vertexBuffer.getMappedRange()).set(interleavedData);
     vertexBuffer.unmap();
-    // Create index buffer (NO FLIP - pass through)
+    // Create index buffer
     const indexBuffer = device.createBuffer({
         size: indices.byteLength,
         usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
@@ -85,8 +85,7 @@ function createWebGPUBuffers(device, textGeometry) {
     return {
         buffers,
         layout,
-        indexFormat: 'uint32',
-        vertexCount,
+        indexCount,
         dispose() {
             vertexBuffer.destroy();
             indexBuffer.destroy();

package/dist/webgpu/index.d.ts

@@ -10,8 +10,7 @@ interface WebGPUBufferSet {
         vertex: GPUVertexBufferLayout;
         color?: GPUVertexBufferLayout;
     };
-    indexFormat: GPUIndexFormat;
-    vertexCount: number;
+    indexCount: number;
     dispose(): void;
 }
 declare function createWebGPUBuffers(device: GPUDevice, textGeometry: TextGeometryInfo): WebGPUBufferSet;