@chocozhang/three-model-render 1.0.4 → 1.0.6

package/dist/index.js

@@ -67,8 +67,8 @@ function addChildModelLabels(camera, renderer, parentModel, modelLabelsMap, opti
         };
     }
     // Configuration
-    const enableCache = (options === null || options === void 0 ? void 0 : options.enableCache) !== false;
-    const updateInterval = (options === null || options === void 0 ? void 0 : options.updateInterval) || 0;
+    const enableCache = options?.enableCache !== false;
+    const updateInterval = options?.updateInterval || 0;
     // Create label container, absolute positioning, attached to body
     const container = document.createElement('div');
     container.style.position = 'absolute';
@@ -84,11 +84,10 @@ function addChildModelLabels(camera, renderer, parentModel, modelLabelsMap, opti
     let lastUpdateTime = 0;
     // Traverse all child models
     parentModel.traverse((child) => {
-        var _a;
         // Only process Mesh or Group
         if ((child.isMesh || child.type === 'Group')) {
             // Dynamic matching of name to prevent undefined
-            const labelText = (_a = Object.entries(modelLabelsMap).find(([key]) => child.name.includes(key))) === null || _a === void 0 ? void 0 : _a[1];
+            const labelText = Object.entries(modelLabelsMap).find(([key]) => child.name.includes(key))?.[1];
             if (!labelText)
                 return; // Skip if no matching label
             // Create DOM label
@@ -96,11 +95,11 @@ function addChildModelLabels(camera, renderer, parentModel, modelLabelsMap, opti
             el.innerText = labelText;
             // Styles defined in JS, can be overridden via options
             el.style.position = 'absolute';
-            el.style.color = (options === null || options === void 0 ? void 0 : options.color) || '#fff';
-            el.style.background = (options === null || options === void 0 ? void 0 : options.background) || 'rgba(0,0,0,0.6)';
-            el.style.padding = (options === null || options === void 0 ? void 0 : options.padding) || '4px 8px';
-            el.style.borderRadius = (options === null || options === void 0 ? void 0 : options.borderRadius) || '4px';
-            el.style.fontSize = (options === null || options === void 0 ? void 0 : options.fontSize) || '14px';
+            el.style.color = options?.color || '#fff';
+            el.style.background = options?.background || 'rgba(0,0,0,0.6)';
+            el.style.padding = options?.padding || '4px 8px';
+            el.style.borderRadius = options?.borderRadius || '4px';
+            el.style.fontSize = options?.fontSize || '14px';
             el.style.transform = 'translate(-50%, -100%)'; // Position label directly above the model
             el.style.whiteSpace = 'nowrap';
             el.style.pointerEvents = 'none';
@@ -481,6 +480,67 @@ function initPostProcessing(renderer, scene, camera, options = {}) {
     };
 }
 
+/**
+ * ResourceManager
+ * Handles tracking and disposal of Three.js objects to prevent memory leaks.
+ */
+class ResourceManager {
+    constructor() {
+        this.geometries = new Set();
+        this.materials = new Set();
+        this.textures = new Set();
+        this.objects = new Set();
+    }
+    /**
+     * Track an object and its resources recursively
+     */
+    track(object) {
+        this.objects.add(object);
+        object.traverse((child) => {
+            if (child.isMesh) {
+                const mesh = child;
+                if (mesh.geometry)
+                    this.geometries.add(mesh.geometry);
+                if (mesh.material) {
+                    if (Array.isArray(mesh.material)) {
+                        mesh.material.forEach(m => this.trackMaterial(m));
+                    }
+                    else {
+                        this.trackMaterial(mesh.material);
+                    }
+                }
+            }
+        });
+        return object;
+    }
+    trackMaterial(material) {
+        this.materials.add(material);
+        // Track textures in material
+        for (const value of Object.values(material)) {
+            if (value instanceof THREE__namespace.Texture) {
+                this.textures.add(value);
+            }
+        }
+    }
+    /**
+     * Dispose all tracked resources
+     */
+    dispose() {
+        this.geometries.forEach(g => g.dispose());
+        this.materials.forEach(m => m.dispose());
+        this.textures.forEach(t => t.dispose());
+        this.objects.forEach(obj => {
+            if (obj.parent) {
+                obj.parent.remove(obj);
+            }
+        });
+        this.geometries.clear();
+        this.materials.clear();
+        this.textures.clear();
+        this.objects.clear();
+    }
+}
+
 /**
  * @file clickHandler.ts
  * @description
@@ -632,7 +692,6 @@ function createModelClickHandler(camera, scene, renderer, outlinePass, onClick,
  */
 class ArrowGuide {
     constructor(renderer, camera, scene, options) {
-        var _a, _b, _c;
         this.renderer = renderer;
         this.camera = camera;
         this.scene = scene;
@@ -651,10 +710,10 @@ class ArrowGuide {
         // Config: Non-highlight opacity and brightness
         this.fadeOpacity = 0.5;
         this.fadeBrightness = 0.1;
-        this.clickThreshold = (_a = options === null || options === void 0 ? void 0 : options.clickThreshold) !== null && _a !== void 0 ? _a : 10;
-        this.ignoreRaycastNames = new Set((options === null || options === void 0 ? void 0 : options.ignoreRaycastNames) || []);
-        this.fadeOpacity = (_b = options === null || options === void 0 ? void 0 : options.fadeOpacity) !== null && _b !== void 0 ? _b : 0.5;
-        this.fadeBrightness = (_c = options === null || options === void 0 ? void 0 : options.fadeBrightness) !== null && _c !== void 0 ? _c : 0.1;
+        this.clickThreshold = options?.clickThreshold ?? 10;
+        this.ignoreRaycastNames = new Set(options?.ignoreRaycastNames || []);
+        this.fadeOpacity = options?.fadeOpacity ?? 0.5;
+        this.fadeBrightness = options?.fadeBrightness ?? 0.1;
         this.abortController = new AbortController();
         this.initEvents();
     }
@@ -892,7 +951,8 @@ class ArrowGuide {
  * LiquidFillerGroup - Optimized
  * Supports single or multi-model liquid level animation with independent color control.
  *
- * Features:
+ * Capabilities:
+ * - Supports THREE.Object3D, Array<THREE.Object3D>, Set<THREE.Object3D> etc.
  * - Uses renderer.domElement instead of window events
  * - Uses AbortController to manage event lifecycle
  * - Adds error handling and boundary checks
@@ -902,7 +962,7 @@ class ArrowGuide {
 class LiquidFillerGroup {
     /**
      * Constructor
-     * @param models Single or multiple THREE.Object3D
+     * @param models Single or multiple THREE.Object3D (Array, Set, etc.)
      * @param scene Scene
      * @param camera Camera
      * @param renderer Renderer
@@ -942,14 +1002,13 @@ class LiquidFillerGroup {
         this.clickThreshold = clickThreshold;
         // Create AbortController for event management
         this.abortController = new AbortController();
-        const modelArray = Array.isArray(models) ? models : [models];
+        const modelArray = this.normalizeInput(models);
         modelArray.forEach(model => {
-            var _a, _b, _c;
             try {
                 const options = {
-                    color: (_a = defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.color) !== null && _a !== void 0 ? _a : 0x00ff00,
-                    opacity: (_b = defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.opacity) !== null && _b !== void 0 ? _b : 0.6,
-                    speed: (_c = defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions.speed) !== null && _c !== void 0 ? _c : 0.05,
+                    color: defaultOptions?.color ?? 0x00ff00,
+                    opacity: defaultOptions?.opacity ?? 0.6,
+                    speed: defaultOptions?.speed ?? 0.05,
                 };
                 // Save original materials
                 const originalMaterials = new Map();
@@ -1026,9 +1085,22 @@ class LiquidFillerGroup {
         this.renderer.domElement.addEventListener('pointerdown', this.handlePointerDown, { signal });
         this.renderer.domElement.addEventListener('pointerup', this.handlePointerUp, { signal });
     }
+    /**
+     * Helper to normalize input to Array<THREE.Object3D>
+     */
+    normalizeInput(models) {
+        if (models instanceof THREE__namespace.Object3D) {
+            return [models];
+        }
+        if (Array.isArray(models)) {
+            return models;
+        }
+        // Handle Iterable (Set, etc.)
+        return Array.from(models);
+    }
     /**
      * Set liquid level
-     * @param models Single model or array of models
+     * @param models Single model or array/iterable of models
      * @param percent Liquid level percentage 0~1
      */
     fillTo(models, percent) {
@@ -1037,7 +1109,7 @@ class LiquidFillerGroup {
             console.warn('LiquidFillerGroup: percent must be between 0 and 1', percent);
             percent = Math.max(0, Math.min(1, percent));
         }
-        const modelArray = Array.isArray(models) ? models : [models];
+        const modelArray = this.normalizeInput(models);
         modelArray.forEach(model => {
             const item = this.items.find(i => i.model === model);
             if (!item) {
@@ -1196,7 +1268,6 @@ const EASING_FUNCTIONS = {
  * - Robust error handling
  */
 function followModels(camera, targets, options = {}) {
-    var _a, _b, _c, _d, _e, _f;
     // Cancel previous animation
     cancelFollow(camera);
     // Boundary check
@@ -1223,14 +1294,14 @@ function followModels(camera, targets, options = {}) {
         box.getBoundingSphere(sphere);
         const center = sphere.center.clone();
         const radiusBase = Math.max(0.001, sphere.radius);
-        const duration = (_a = options.duration) !== null && _a !== void 0 ? _a : 700;
-        const padding = (_b = options.padding) !== null && _b !== void 0 ? _b : 1.0;
+        const duration = options.duration ?? 700;
+        const padding = options.padding ?? 1.0;
         const minDistance = options.minDistance;
         const maxDistance = options.maxDistance;
-        const controls = (_c = options.controls) !== null && _c !== void 0 ? _c : null;
-        const azimuth = (_d = options.azimuth) !== null && _d !== void 0 ? _d : Math.PI / 4;
-        const elevation = (_e = options.elevation) !== null && _e !== void 0 ? _e : Math.PI / 4;
-        const easing = (_f = options.easing) !== null && _f !== void 0 ? _f : 'easeOut';
+        const controls = options.controls ?? null;
+        const azimuth = options.azimuth ?? Math.PI / 4;
+        const elevation = options.elevation ?? Math.PI / 4;
+        const easing = options.easing ?? 'easeOut';
         const onProgress = options.onProgress;
         // Get easing function
         const easingFn = EASING_FUNCTIONS[easing] || EASING_FUNCTIONS.easeOut;
@@ -1368,9 +1439,6 @@ function setView(camera, controls, targetObj, position = 'front', options = {})
             console.warn('setView: Failed to calculate bounding box');
             return Promise.reject(new Error('Invalid bounding box'));
         }
-        const center = box.getCenter(new THREE__namespace.Vector3());
-        const size = box.getSize(new THREE__namespace.Vector3());
-        const maxSize = Math.max(size.x, size.y, size.z);
         // Use mapping table for creating view angles
         const viewAngles = {
             'front': { azimuth: 0, elevation: 0 },
@@ -1422,37 +1490,22 @@ const ViewPresets = {
     top: (camera, controls, target, options) => setView(camera, controls, target, 'top', options)
 };
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+let globalConfig = {
+    dracoDecoderPath: '/draco/',
+    ktx2TranscoderPath: '/basis/',
 };
+/**
+ * Update global loader configuration (e.g., set path to CDN)
+ */
+function setLoaderConfig(config) {
+    globalConfig = { ...globalConfig, ...config };
+}
+/**
+ * Get current global loader configuration
+ */
+function getLoaderConfig() {
+    return globalConfig;
+}
 
 /**
  * @file modelLoader.ts
@@ -1470,19 +1523,22 @@ const DEFAULT_OPTIONS$1 = {
     maxTextureSize: null,
     useSimpleMaterials: false,
     skipSkinned: true,
+    useCache: true,
 };
+const modelCache = new Map();
 /** Automatically determine which options to enable based on extension (smart judgment) */
 function normalizeOptions(url, opts) {
     const ext = (url.split('.').pop() || '').toLowerCase();
-    const merged = Object.assign(Object.assign({}, DEFAULT_OPTIONS$1), opts);
+    const merged = { ...DEFAULT_OPTIONS$1, ...opts };
     if (ext === 'gltf' || ext === 'glb') {
+        const globalConfig = getLoaderConfig();
         // gltf/glb defaults to trying draco/ktx2 if user didn't specify
         if (merged.dracoDecoderPath === undefined)
-            merged.dracoDecoderPath = '/draco/';
+            merged.dracoDecoderPath = globalConfig.dracoDecoderPath;
         if (merged.useKTX2 === undefined)
             merged.useKTX2 = true;
         if (merged.ktx2TranscoderPath === undefined)
-            merged.ktx2TranscoderPath = '/basis/';
+            merged.ktx2TranscoderPath = globalConfig.ktx2TranscoderPath;
     }
     else {
         // fbx/obj/ply/stl etc. do not need draco/ktx2
@@ -1492,103 +1548,108 @@ function normalizeOptions(url, opts) {
     }
     return merged;
 }
-function loadModelByUrl(url_1) {
-    return __awaiter(this, arguments, void 0, function* (url, options = {}) {
-        var _a, _b;
-        if (!url)
-            throw new Error('url required');
-        const ext = (url.split('.').pop() || '').toLowerCase();
-        const opts = normalizeOptions(url, options);
-        const manager = (_a = opts.manager) !== null && _a !== void 0 ? _a : new THREE__namespace.LoadingManager();
-        let loader;
-        if (ext === 'gltf' || ext === 'glb') {
-            const { GLTFLoader } = yield import('three/examples/jsm/loaders/GLTFLoader.js');
-            const gltfLoader = new GLTFLoader(manager);
-            if (opts.dracoDecoderPath) {
-                const { DRACOLoader } = yield import('three/examples/jsm/loaders/DRACOLoader.js');
-                const draco = new DRACOLoader();
-                draco.setDecoderPath(opts.dracoDecoderPath);
-                gltfLoader.setDRACOLoader(draco);
-            }
-            if (opts.useKTX2 && opts.ktx2TranscoderPath) {
-                const { KTX2Loader } = yield import('three/examples/jsm/loaders/KTX2Loader.js');
-                const ktx2Loader = new KTX2Loader().setTranscoderPath(opts.ktx2TranscoderPath);
-                gltfLoader.__ktx2Loader = ktx2Loader;
-            }
-            loader = gltfLoader;
-        }
-        else if (ext === 'fbx') {
-            const { FBXLoader } = yield import('three/examples/jsm/loaders/FBXLoader.js');
-            loader = new FBXLoader(manager);
-        }
-        else if (ext === 'obj') {
-            const { OBJLoader } = yield import('three/examples/jsm/loaders/OBJLoader.js');
-            loader = new OBJLoader(manager);
-        }
-        else if (ext === 'ply') {
-            const { PLYLoader } = yield import('three/examples/jsm/loaders/PLYLoader.js');
-            loader = new PLYLoader(manager);
-        }
-        else if (ext === 'stl') {
-            const { STLLoader } = yield import('three/examples/jsm/loaders/STLLoader.js');
-            loader = new STLLoader(manager);
+async function loadModelByUrl(url, options = {}) {
+    if (!url)
+        throw new Error('url required');
+    const ext = (url.split('.').pop() || '').toLowerCase();
+    const opts = normalizeOptions(url, options);
+    const manager = opts.manager ?? new THREE__namespace.LoadingManager();
+    // Cache key includes URL and relevant optimization options
+    const cacheKey = `${url}_${opts.mergeGeometries}_${opts.maxTextureSize}_${opts.useSimpleMaterials}`;
+    if (opts.useCache && modelCache.has(cacheKey)) {
+        return modelCache.get(cacheKey).clone();
+    }
+    let loader;
+    if (ext === 'gltf' || ext === 'glb') {
+        const { GLTFLoader } = await import('three/examples/jsm/loaders/GLTFLoader.js');
+        const gltfLoader = new GLTFLoader(manager);
+        if (opts.dracoDecoderPath) {
+            const { DRACOLoader } = await import('three/examples/jsm/loaders/DRACOLoader.js');
+            const draco = new DRACOLoader();
+            draco.setDecoderPath(opts.dracoDecoderPath);
+            gltfLoader.setDRACOLoader(draco);
         }
-        else {
-            throw new Error(`Unsupported model extension: .${ext}`);
-        }
-        const object = yield new Promise((resolve, reject) => {
-            loader.load(url, (res) => {
-                var _a;
-                if (ext === 'gltf' || ext === 'glb') {
-                    const sceneObj = res.scene || res;
-                    // --- Critical: Expose animations to scene.userData (or scene.animations) ---
-                    // So the caller can access clips simply by getting sceneObj.userData.animations
-                    sceneObj.userData = (sceneObj === null || sceneObj === void 0 ? void 0 : sceneObj.userData) || {};
-                    sceneObj.userData.animations = (_a = res.animations) !== null && _a !== void 0 ? _a : [];
-                    resolve(sceneObj);
-                }
-                else {
-                    resolve(res);
-                }
-            }, undefined, (err) => reject(err));
-        });
-        // Optimize
-        object.traverse((child) => {
-            var _a, _b, _c;
-            const mesh = child;
-            if (mesh.isMesh && mesh.geometry && !mesh.geometry.isBufferGeometry) {
-                try {
-                    mesh.geometry = (_c = (_b = (_a = new THREE__namespace.BufferGeometry()).fromGeometry) === null || _b === void 0 ? void 0 : _b.call(_a, mesh.geometry)) !== null && _c !== void 0 ? _c : mesh.geometry;
-                }
-                catch (_d) { }
-            }
-        });
-        if (opts.maxTextureSize && opts.maxTextureSize > 0)
-            downscaleTexturesInObject(object, opts.maxTextureSize);
-        if (opts.useSimpleMaterials) {
-            object.traverse((child) => {
-                const m = child.material;
-                if (!m)
-                    return;
-                if (Array.isArray(m))
-                    child.material = m.map((mat) => toSimpleMaterial(mat));
-                else
-                    child.material = toSimpleMaterial(m);
-            });
+        if (opts.useKTX2 && opts.ktx2TranscoderPath) {
+            const { KTX2Loader } = await import('three/examples/jsm/loaders/KTX2Loader.js');
+            const ktx2Loader = new KTX2Loader().setTranscoderPath(opts.ktx2TranscoderPath);
+            gltfLoader.__ktx2Loader = ktx2Loader;
         }
-        if (opts.mergeGeometries) {
-            try {
-                yield tryMergeGeometries(object, { skipSkinned: (_b = opts.skipSkinned) !== null && _b !== void 0 ? _b : true });
+        loader = gltfLoader;
+    }
+    else if (ext === 'fbx') {
+        const { FBXLoader } = await import('three/examples/jsm/loaders/FBXLoader.js');
+        loader = new FBXLoader(manager);
+    }
+    else if (ext === 'obj') {
+        const { OBJLoader } = await import('three/examples/jsm/loaders/OBJLoader.js');
+        loader = new OBJLoader(manager);
+    }
+    else if (ext === 'ply') {
+        const { PLYLoader } = await import('three/examples/jsm/loaders/PLYLoader.js');
+        loader = new PLYLoader(manager);
+    }
+    else if (ext === 'stl') {
+        const { STLLoader } = await import('three/examples/jsm/loaders/STLLoader.js');
+        loader = new STLLoader(manager);
+    }
+    else {
+        throw new Error(`Unsupported model extension: .${ext}`);
+    }
+    const object = await new Promise((resolve, reject) => {
+        loader.load(url, (res) => {
+            if (ext === 'gltf' || ext === 'glb') {
+                const sceneObj = res.scene || res;
+                // --- Critical: Expose animations to scene.userData (or scene.animations) ---
+                // So the caller can access clips simply by getting sceneObj.userData.animations
+                sceneObj.userData = sceneObj?.userData || {};
+                sceneObj.userData.animations = res.animations ?? [];
+                resolve(sceneObj);
             }
-            catch (e) {
-                console.warn('mergeGeometries failed', e);
+            else {
+                resolve(res);
+            }
+        }, undefined, (err) => reject(err));
+    });
+    // Optimize
+    object.traverse((child) => {
+        const mesh = child;
+        if (mesh.isMesh && mesh.geometry && !mesh.geometry.isBufferGeometry) {
+            try {
+                mesh.geometry = new THREE__namespace.BufferGeometry().fromGeometry?.(mesh.geometry) ?? mesh.geometry;
             }
+            catch { }
         }
-        return object;
     });
+    if (opts.maxTextureSize && opts.maxTextureSize > 0)
+        await downscaleTexturesInObject(object, opts.maxTextureSize);
+    if (opts.useSimpleMaterials) {
+        object.traverse((child) => {
+            const m = child.material;
+            if (!m)
+                return;
+            if (Array.isArray(m))
+                child.material = m.map((mat) => toSimpleMaterial(mat));
+            else
+                child.material = toSimpleMaterial(m);
+        });
+    }
+    if (opts.mergeGeometries) {
+        try {
+            await tryMergeGeometries(object, { skipSkinned: opts.skipSkinned ?? true });
+        }
+        catch (e) {
+            console.warn('mergeGeometries failed', e);
+        }
+    }
+    if (opts.useCache) {
+        modelCache.set(cacheKey, object);
+        return object.clone();
+    }
+    return object;
 }
-/** Runtime downscale textures in mesh to maxSize (canvas drawImage) to save GPU memory */
-function downscaleTexturesInObject(obj, maxSize) {
+/** Runtime downscale textures in mesh to maxSize (createImageBitmap or canvas) to save GPU memory */
+async function downscaleTexturesInObject(obj, maxSize) {
+    const tasks = [];
     obj.traverse((ch) => {
         if (!ch.isMesh)
             return;
@@ -1607,27 +1668,44 @@ function downscaleTexturesInObject(obj, maxSize) {
             const max = maxSize;
             if (image.width <= max && image.height <= max)
                 return;
-            // downscale using canvas (sync, may be heavy for many textures)
-            try {
-                const scale = Math.min(max / image.width, max / image.height);
-                const canvas = document.createElement('canvas');
-                canvas.width = Math.floor(image.width * scale);
-                canvas.height = Math.floor(image.height * scale);
-                const ctx = canvas.getContext('2d');
-                if (ctx) {
-                    ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
-                    const newTex = new THREE__namespace.Texture(canvas);
-                    newTex.needsUpdate = true;
-                    // copy common settings (encoding etc)
-                    newTex.encoding = tex.encoding;
-                    mat[p] = newTex;
+            tasks.push((async () => {
+                try {
+                    const scale = Math.min(max / image.width, max / image.height);
+                    const newWidth = Math.floor(image.width * scale);
+                    const newHeight = Math.floor(image.height * scale);
+                    let newSource;
+                    if (typeof createImageBitmap !== 'undefined') {
+                        newSource = await createImageBitmap(image, {
+                            resizeWidth: newWidth,
+                            resizeHeight: newHeight,
+                            resizeQuality: 'high'
+                        });
+                    }
+                    else {
+                        // Fallback for environments without createImageBitmap
+                        const canvas = document.createElement('canvas');
+                        canvas.width = newWidth;
+                        canvas.height = newHeight;
+                        const ctx = canvas.getContext('2d');
+                        if (ctx) {
+                            ctx.drawImage(image, 0, 0, newWidth, newHeight);
+                            newSource = canvas;
+                        }
+                    }
+                    if (newSource) {
+                        const newTex = new THREE__namespace.Texture(newSource);
+                        newTex.needsUpdate = true;
+                        newTex.encoding = tex.encoding;
+                        mat[p] = newTex;
+                    }
                 }
-            }
-            catch (e) {
-                console.warn('downscale texture failed', e);
-            }
+                catch (e) {
+                    console.warn('downscale texture failed', e);
+                }
+            })());
         });
     });
+    await Promise.all(tasks);
 }
 /**
  * Try to merge geometries in object (Only merge: non-transparent, non-SkinnedMesh, attribute compatible BufferGeometry)
@@ -1635,81 +1713,77 @@ function downscaleTexturesInObject(obj, maxSize) {
  * - Merging will group by material UUID (different materials cannot be merged)
  * - Merge function is compatible with common export names of BufferGeometryUtils
  */
-function tryMergeGeometries(root, opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // collect meshes by material uuid
-        const groups = new Map();
-        root.traverse((ch) => {
-            var _a;
-            if (!ch.isMesh)
-                return;
-            const mesh = ch;
-            if (opts.skipSkinned && mesh.isSkinnedMesh)
-                return;
-            const mat = mesh.material;
-            // don't merge transparent or morph-enabled or skinned meshes
-            if (!mesh.geometry || mesh.visible === false)
-                return;
-            if (mat && mat.transparent)
-                return;
-            const geom = mesh.geometry.clone();
-            mesh.updateWorldMatrix(true, false);
-            geom.applyMatrix4(mesh.matrixWorld);
-            // ensure attributes compatible? we'll rely on merge function to return null if incompatible
-            const key = (mat && mat.uuid) || 'default';
-            const bucket = (_a = groups.get(key)) !== null && _a !== void 0 ? _a : { material: mat !== null && mat !== void 0 ? mat : new THREE__namespace.MeshStandardMaterial(), geoms: [] };
-            bucket.geoms.push(geom);
-            groups.set(key, bucket);
-            // mark for removal (we'll remove meshes after)
-            mesh.userData.__toRemoveForMerge = true;
-        });
-        if (groups.size === 0)
+async function tryMergeGeometries(root, opts) {
+    // collect meshes by material uuid
+    const groups = new Map();
+    root.traverse((ch) => {
+        if (!ch.isMesh)
             return;
-        // dynamic import BufferGeometryUtils and find merge function name
-        const bufUtilsMod = yield import('three/examples/jsm/utils/BufferGeometryUtils.js');
-        // use || chain (avoid mixing ?? with || without parentheses)
-        const mergeFn = bufUtilsMod.mergeBufferGeometries ||
-            bufUtilsMod.mergeGeometries ||
-            bufUtilsMod.mergeBufferGeometries || // defensive duplicate
-            bufUtilsMod.mergeGeometries;
-        if (!mergeFn)
-            throw new Error('No merge function found in BufferGeometryUtils');
-        // for each group, try merge
-        for (const [key, { material, geoms }] of groups) {
-            if (geoms.length <= 1) {
-                // nothing to merge
-                continue;
-            }
-            // call merge function - signature typically mergeBufferGeometries(array, useGroups)
-            const merged = mergeFn(geoms, false);
-            if (!merged) {
-                console.warn('merge returned null for group', key);
-                continue;
+        const mesh = ch;
+        if (opts.skipSkinned && mesh.isSkinnedMesh)
+            return;
+        const mat = mesh.material;
+        // don't merge transparent or morph-enabled or skinned meshes
+        if (!mesh.geometry || mesh.visible === false)
+            return;
+        if (mat && mat.transparent)
+            return;
+        const geom = mesh.geometry.clone();
+        mesh.updateWorldMatrix(true, false);
+        geom.applyMatrix4(mesh.matrixWorld);
+        // ensure attributes compatible? we'll rely on merge function to return null if incompatible
+        const key = (mat && mat.uuid) || 'default';
+        const bucket = groups.get(key) ?? { material: mat ?? new THREE__namespace.MeshStandardMaterial(), geoms: [] };
+        bucket.geoms.push(geom);
+        groups.set(key, bucket);
+        // mark for removal (we'll remove meshes after)
+        mesh.userData.__toRemoveForMerge = true;
+    });
+    if (groups.size === 0)
+        return;
+    // dynamic import BufferGeometryUtils and find merge function name
+    const bufUtilsMod = await import('three/examples/jsm/utils/BufferGeometryUtils.js');
+    // use || chain (avoid mixing ?? with || without parentheses)
+    const mergeFn = bufUtilsMod.mergeBufferGeometries ||
+        bufUtilsMod.mergeGeometries ||
+        bufUtilsMod.mergeBufferGeometries || // defensive duplicate
+        bufUtilsMod.mergeGeometries;
+    if (!mergeFn)
+        throw new Error('No merge function found in BufferGeometryUtils');
+    // for each group, try merge
+    for (const [key, { material, geoms }] of groups) {
+        if (geoms.length <= 1) {
+            // nothing to merge
+            continue;
+        }
+        // call merge function - signature typically mergeBufferGeometries(array, useGroups)
+        const merged = mergeFn(geoms, false);
+        if (!merged) {
+            console.warn('merge returned null for group', key);
+            continue;
+        }
+        // create merged mesh at root (world-space geometry already applied)
+        const mergedMesh = new THREE__namespace.Mesh(merged, material);
+        root.add(mergedMesh);
+    }
+    // now remove original meshes flagged for removal
+    const toRemove = [];
+    root.traverse((ch) => {
+        if (ch.userData?.__toRemoveForMerge)
+            toRemove.push(ch);
+    });
+    toRemove.forEach((m) => {
+        if (m.parent)
+            m.parent.remove(m);
+        // free original resources (geometries already cloned/applied), but careful with shared materials
+        if (m.isMesh) {
+            const mm = m;
+            try {
+                mm.geometry.dispose();
             }
-            // create merged mesh at root (world-space geometry already applied)
-            const mergedMesh = new THREE__namespace.Mesh(merged, material);
-            root.add(mergedMesh);
+            catch { }
+            // we do NOT dispose material because it may be reused by mergedMesh
         }
-        // now remove original meshes flagged for removal
-        const toRemove = [];
-        root.traverse((ch) => {
-            var _a;
-            if ((_a = ch.userData) === null || _a === void 0 ? void 0 : _a.__toRemoveForMerge)
-                toRemove.push(ch);
-        });
-        toRemove.forEach((m) => {
-            if (m.parent)
-                m.parent.remove(m);
-            // free original resources (geometries already cloned/applied), but careful with shared materials
-            if (m.isMesh) {
-                const mm = m;
-                try {
-                    mm.geometry.dispose();
-                }
-                catch (_a) { }
-                // we do NOT dispose material because it may be reused by mergedMesh
-            }
-        });
     });
 }
 /* ---------------------
@@ -1726,7 +1800,7 @@ function disposeObject(obj) {
                 try {
                     m.geometry.dispose();
                 }
-                catch (_a) { }
+                catch { }
             }
             const mat = m.material;
             if (mat) {
@@ -1748,14 +1822,14 @@ function disposeMaterial(mat) {
             try {
                 mat[k].dispose();
             }
-            catch (_a) { }
+            catch { }
         }
     });
     try {
         if (typeof mat.dispose === 'function')
             mat.dispose();
     }
-    catch (_a) { }
+    catch { }
 }
 // Helper to convert to simple material (stub)
 function toSimpleMaterial(mat) {
@@ -1798,100 +1872,97 @@ const equirectCache = new Map();
  * @param paths string[] 6 image paths, order: [px, nx, py, ny, pz, nz]
  * @param opts SkyboxOptions
  */
-function loadCubeSkybox(renderer_1, scene_1, paths_1) {
-    return __awaiter(this, arguments, void 0, function* (renderer, scene, paths, opts = {}) {
-        var _a, _b;
-        const options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), opts);
-        if (!Array.isArray(paths) || paths.length !== 6)
-            throw new Error('cube skybox requires 6 image paths');
-        const key = paths.join('|');
-        // Cache handling
-        if (options.cache && cubeCache.has(key)) {
-            const rec = cubeCache.get(key);
-            rec.refCount += 1;
-            // reapply to scene (in case it was removed)
-            if (options.setAsBackground)
-                scene.background = rec.handle.backgroundTexture;
-            if (options.setAsEnvironment && rec.handle.envRenderTarget)
-                scene.environment = rec.handle.envRenderTarget.texture;
-            return rec.handle;
-        }
-        // Load cube texture
-        const loader = new THREE__namespace.CubeTextureLoader();
-        const texture = yield new Promise((resolve, reject) => {
-            loader.load(paths, (tex) => resolve(tex), undefined, (err) => reject(err));
-        });
-        // Set encoding and mapping
-        if (options.useSRGBEncoding)
-            texture.encoding = THREE__namespace.sRGBEncoding;
-        texture.mapping = THREE__namespace.CubeReflectionMapping;
-        // apply as background if required
+async function loadCubeSkybox(renderer, scene, paths, opts = {}) {
+    const options = { ...DEFAULT_OPTIONS, ...opts };
+    if (!Array.isArray(paths) || paths.length !== 6)
+        throw new Error('cube skybox requires 6 image paths');
+    const key = paths.join('|');
+    // Cache handling
+    if (options.cache && cubeCache.has(key)) {
+        const rec = cubeCache.get(key);
+        rec.refCount += 1;
+        // reapply to scene (in case it was removed)
         if (options.setAsBackground)
-            scene.background = texture;
-        // environment: use PMREM to produce a proper prefiltered env map for PBR
-        let pmremGenerator = (_a = options.pmremGenerator) !== null && _a !== void 0 ? _a : new THREE__namespace.PMREMGenerator(renderer);
-        (_b = pmremGenerator.compileCubemapShader) === null || _b === void 0 ? void 0 : _b.call(pmremGenerator);
-        // fromCubemap might be available in your three.js; fallback to fromEquirectangular approach if not
-        let envRenderTarget = null;
-        if (pmremGenerator.fromCubemap) {
-            envRenderTarget = pmremGenerator.fromCubemap(texture);
+            scene.background = rec.handle.backgroundTexture;
+        if (options.setAsEnvironment && rec.handle.envRenderTarget)
+            scene.environment = rec.handle.envRenderTarget.texture;
+        return rec.handle;
+    }
+    // Load cube texture
+    const loader = new THREE__namespace.CubeTextureLoader();
+    const texture = await new Promise((resolve, reject) => {
+        loader.load(paths, (tex) => resolve(tex), undefined, (err) => reject(err));
+    });
+    // Set encoding and mapping
+    if (options.useSRGBEncoding)
+        texture.encoding = THREE__namespace.sRGBEncoding;
+    texture.mapping = THREE__namespace.CubeReflectionMapping;
+    // apply as background if required
+    if (options.setAsBackground)
+        scene.background = texture;
+    // environment: use PMREM to produce a proper prefiltered env map for PBR
+    let pmremGenerator = options.pmremGenerator ?? new THREE__namespace.PMREMGenerator(renderer);
+    pmremGenerator.compileCubemapShader?.( /* optional */);
+    // fromCubemap might be available in your three.js; fallback to fromEquirectangular approach if not
+    let envRenderTarget = null;
+    if (pmremGenerator.fromCubemap) {
+        envRenderTarget = pmremGenerator.fromCubemap(texture);
+    }
+    else {
+        // Fallback: render cube to env map by using generator.fromEquirectangular with a converted equirect if needed.
+        // Simpler fallback: use the cube texture directly as environment (less correct for reflections).
+        envRenderTarget = null;
+    }
+    if (options.setAsEnvironment) {
+        if (envRenderTarget) {
+            scene.environment = envRenderTarget.texture;
         }
         else {
-            // Fallback: render cube to env map by using generator.fromEquirectangular with a converted equirect if needed.
-            // Simpler fallback: use the cube texture directly as environment (less correct for reflections).
-            envRenderTarget = null;
+            // fallback: use cube texture directly (works but not prefiltered)
+            scene.environment = texture;
         }
-        if (options.setAsEnvironment) {
-            if (envRenderTarget) {
-                scene.environment = envRenderTarget.texture;
+    }
+    const handle = {
+        key,
+        backgroundTexture: options.setAsBackground ? texture : null,
+        envRenderTarget: envRenderTarget,
+        pmremGenerator: options.pmremGenerator ? null : pmremGenerator, // only dispose if we created it
+        setAsBackground: !!options.setAsBackground,
+        setAsEnvironment: !!options.setAsEnvironment,
+        dispose() {
+            // remove from scene
+            if (options.setAsBackground && scene.background === texture)
+                scene.background = null;
+            if (options.setAsEnvironment && scene.environment) {
+                // only clear if it's the same texture we set
+                if (envRenderTarget && scene.environment === envRenderTarget.texture)
+                    scene.environment = null;
+                else if (scene.environment === texture)
+                    scene.environment = null;
             }
-            else {
-                // fallback: use cube texture directly (works but not prefiltered)
-                scene.environment = texture;
-            }
-        }
-        const handle = {
-            key,
-            backgroundTexture: options.setAsBackground ? texture : null,
-            envRenderTarget: envRenderTarget,
-            pmremGenerator: options.pmremGenerator ? null : pmremGenerator, // only dispose if we created it
-            setAsBackground: !!options.setAsBackground,
-            setAsEnvironment: !!options.setAsEnvironment,
-            dispose() {
-                // remove from scene
-                if (options.setAsBackground && scene.background === texture)
-                    scene.background = null;
-                if (options.setAsEnvironment && scene.environment) {
-                    // only clear if it's the same texture we set
-                    if (envRenderTarget && scene.environment === envRenderTarget.texture)
-                        scene.environment = null;
-                    else if (scene.environment === texture)
-                        scene.environment = null;
-                }
-                // dispose resources only if not cached/shared
-                if (envRenderTarget) {
-                    try {
-                        envRenderTarget.dispose();
-                    }
-                    catch (_a) { }
-                }
+            // dispose resources only if not cached/shared
+            if (envRenderTarget) {
                 try {
-                    texture.dispose();
+                    envRenderTarget.dispose();
                 }
-                catch (_b) { }
-                // dispose pmremGenerator we created
-                if (!options.pmremGenerator && pmremGenerator) {
-                    try {
-                        pmremGenerator.dispose();
-                    }
-                    catch (_c) { }
+                catch { }
+            }
+            try {
+                texture.dispose();
+            }
+            catch { }
+            // dispose pmremGenerator we created
+            if (!options.pmremGenerator && pmremGenerator) {
+                try {
+                    pmremGenerator.dispose();
                 }
+                catch { }
             }
-        };
-        if (options.cache)
-            cubeCache.set(key, { handle, refCount: 1 });
-        return handle;
-    });
+        }
+    };
+    if (options.cache)
+        cubeCache.set(key, { handle, refCount: 1 });
+    return handle;
 }
 /**
  * Load Equirectangular/Single Image (Supports HDR via RGBELoader)
@@ -1900,95 +1971,90 @@ function loadCubeSkybox(renderer_1, scene_1, paths_1) {
  * @param url string - *.hdr, *.exr, *.jpg, *.png
  * @param opts SkyboxOptions
  */
-function loadEquirectSkybox(renderer_1, scene_1, url_1) {
-    return __awaiter(this, arguments, void 0, function* (renderer, scene, url, opts = {}) {
-        var _a, _b;
-        const options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), opts);
-        const key = url;
-        if (options.cache && equirectCache.has(key)) {
-            const rec = equirectCache.get(key);
-            rec.refCount += 1;
-            if (options.setAsBackground)
-                scene.background = rec.handle.backgroundTexture;
-            if (options.setAsEnvironment && rec.handle.envRenderTarget)
-                scene.environment = rec.handle.envRenderTarget.texture;
-            return rec.handle;
-        }
-        // Dynamically import RGBELoader (for .hdr/.exr), if loading normal jpg/png directly use TextureLoader
-        const isHDR = /\.hdr$|\.exr$/i.test(url);
-        let hdrTexture;
-        if (isHDR) {
-            const { RGBELoader } = yield import('three/examples/jsm/loaders/RGBELoader.js');
-            hdrTexture = yield new Promise((resolve, reject) => {
-                new RGBELoader().load(url, (tex) => resolve(tex), undefined, (err) => reject(err));
-            });
-            // RGBE textures typically use LinearEncoding
-            hdrTexture.encoding = THREE__namespace.LinearEncoding;
-        }
-        else {
-            // ordinary image - use TextureLoader
-            const loader = new THREE__namespace.TextureLoader();
-            hdrTexture = yield new Promise((resolve, reject) => {
-                loader.load(url, (t) => resolve(t), undefined, (err) => reject(err));
-            });
-            if (options.useSRGBEncoding)
-                hdrTexture.encoding = THREE__namespace.sRGBEncoding;
-        }
-        // PMREMGenerator to convert equirectangular to prefiltered cubemap (good for PBR)
-        const pmremGenerator = (_a = options.pmremGenerator) !== null && _a !== void 0 ? _a : new THREE__namespace.PMREMGenerator(renderer);
-        (_b = pmremGenerator.compileEquirectangularShader) === null || _b === void 0 ? void 0 : _b.call(pmremGenerator);
-        const envRenderTarget = pmremGenerator.fromEquirectangular(hdrTexture);
-        // envTexture to use for scene.environment
-        const envTexture = envRenderTarget.texture;
-        // set background and/or environment
-        if (options.setAsBackground) {
-            // for background it's ok to use the equirect texture directly or the envTexture
-            // envTexture is cubemap-like and usually better for reflections; using it as background creates cube-projected look
-            scene.background = envTexture;
-        }
-        if (options.setAsEnvironment) {
-            scene.environment = envTexture;
-        }
-        // We can dispose the original hdrTexture (the PMREM target contains the needed data)
-        try {
-            hdrTexture.dispose();
-        }
-        catch (_c) { }
-        const handle = {
-            key,
-            backgroundTexture: options.setAsBackground ? envTexture : null,
-            envRenderTarget,
-            pmremGenerator: options.pmremGenerator ? null : pmremGenerator,
-            setAsBackground: !!options.setAsBackground,
-            setAsEnvironment: !!options.setAsEnvironment,
-            dispose() {
-                if (options.setAsBackground && scene.background === envTexture)
-                    scene.background = null;
-                if (options.setAsEnvironment && scene.environment === envTexture)
-                    scene.environment = null;
+async function loadEquirectSkybox(renderer, scene, url, opts = {}) {
+    const options = { ...DEFAULT_OPTIONS, ...opts };
+    const key = url;
+    if (options.cache && equirectCache.has(key)) {
+        const rec = equirectCache.get(key);
+        rec.refCount += 1;
+        if (options.setAsBackground)
+            scene.background = rec.handle.backgroundTexture;
+        if (options.setAsEnvironment && rec.handle.envRenderTarget)
+            scene.environment = rec.handle.envRenderTarget.texture;
+        return rec.handle;
+    }
+    // Dynamically import RGBELoader (for .hdr/.exr), if loading normal jpg/png directly use TextureLoader
+    const isHDR = /\.hdr$|\.exr$/i.test(url);
+    let hdrTexture;
+    if (isHDR) {
+        const { RGBELoader } = await import('three/examples/jsm/loaders/RGBELoader.js');
+        hdrTexture = await new Promise((resolve, reject) => {
+            new RGBELoader().load(url, (tex) => resolve(tex), undefined, (err) => reject(err));
+        });
+        // RGBE textures typically use LinearEncoding
+        hdrTexture.encoding = THREE__namespace.LinearEncoding;
+    }
+    else {
+        // ordinary image - use TextureLoader
+        const loader = new THREE__namespace.TextureLoader();
+        hdrTexture = await new Promise((resolve, reject) => {
+            loader.load(url, (t) => resolve(t), undefined, (err) => reject(err));
+        });
+        if (options.useSRGBEncoding)
+            hdrTexture.encoding = THREE__namespace.sRGBEncoding;
+    }
+    // PMREMGenerator to convert equirectangular to prefiltered cubemap (good for PBR)
+    const pmremGenerator = options.pmremGenerator ?? new THREE__namespace.PMREMGenerator(renderer);
+    pmremGenerator.compileEquirectangularShader?.();
+    const envRenderTarget = pmremGenerator.fromEquirectangular(hdrTexture);
+    // envTexture to use for scene.environment
+    const envTexture = envRenderTarget.texture;
+    // set background and/or environment
+    if (options.setAsBackground) {
+        // for background it's ok to use the equirect texture directly or the envTexture
+        // envTexture is cubemap-like and usually better for reflections; using it as background creates cube-projected look
+        scene.background = envTexture;
+    }
+    if (options.setAsEnvironment) {
+        scene.environment = envTexture;
+    }
+    // We can dispose the original hdrTexture (the PMREM target contains the needed data)
+    try {
+        hdrTexture.dispose();
+    }
+    catch { }
+    const handle = {
+        key,
+        backgroundTexture: options.setAsBackground ? envTexture : null,
+        envRenderTarget,
+        pmremGenerator: options.pmremGenerator ? null : pmremGenerator,
+        setAsBackground: !!options.setAsBackground,
+        setAsEnvironment: !!options.setAsEnvironment,
+        dispose() {
+            if (options.setAsBackground && scene.background === envTexture)
+                scene.background = null;
+            if (options.setAsEnvironment && scene.environment === envTexture)
+                scene.environment = null;
+            try {
+                envRenderTarget.dispose();
+            }
+            catch { }
+            if (!options.pmremGenerator && pmremGenerator) {
                 try {
-                    envRenderTarget.dispose();
-                }
-                catch (_a) { }
-                if (!options.pmremGenerator && pmremGenerator) {
-                    try {
-                        pmremGenerator.dispose();
-                    }
-                    catch (_b) { }
+                    pmremGenerator.dispose();
                 }
+                catch { }
             }
-        };
-        if (options.cache)
-            equirectCache.set(key, { handle, refCount: 1 });
-        return handle;
-    });
+        }
+    };
+    if (options.cache)
+        equirectCache.set(key, { handle, refCount: 1 });
+    return handle;
 }
-function loadSkybox(renderer_1, scene_1, params_1) {
-    return __awaiter(this, arguments, void 0, function* (renderer, scene, params, opts = {}) {
-        if (params.type === 'cube')
-            return loadCubeSkybox(renderer, scene, params.paths, opts);
-        return loadEquirectSkybox(renderer, scene, params.url, opts);
-    });
+async function loadSkybox(renderer, scene, params, opts = {}) {
+    if (params.type === 'cube')
+        return loadCubeSkybox(renderer, scene, params.paths, opts);
+    return loadEquirectSkybox(renderer, scene, params.url, opts);
 }
 /* -------------------------
    Cache / Reference Counting Helper Methods
@@ -2198,10 +2264,9 @@ class BlueSkyManager {
      * Usually called when the scene is completely destroyed or the application exits
      */
     destroy() {
-        var _a;
         this.cancelLoad();
         this.dispose();
-        (_a = this.pmremGen) === null || _a === void 0 ? void 0 : _a.dispose();
+        this.pmremGen?.dispose();
         this.isInitialized = false;
         this.loadingState = 'idle';
     }
@@ -2235,20 +2300,19 @@ const BlueSky = new BlueSkyManager();
  * - RAF management optimization
  */
 function createModelsLabel(camera, renderer, parentModel, modelLabelsMap, options) {
-    var _a, _b, _c, _d, _e, _f;
     const cfg = {
-        fontSize: (options === null || options === void 0 ? void 0 : options.fontSize) || '12px',
-        color: (options === null || options === void 0 ? void 0 : options.color) || '#ffffff',
-        background: (options === null || options === void 0 ? void 0 : options.background) || '#1890ff',
-        padding: (options === null || options === void 0 ? void 0 : options.padding) || '6px 10px',
-        borderRadius: (options === null || options === void 0 ? void 0 : options.borderRadius) || '6px',
-        lift: (_a = options === null || options === void 0 ? void 0 : options.lift) !== null && _a !== void 0 ? _a : 100,
-        dotSize: (_b = options === null || options === void 0 ? void 0 : options.dotSize) !== null && _b !== void 0 ? _b : 6,
-        dotSpacing: (_c = options === null || options === void 0 ? void 0 : options.dotSpacing) !== null && _c !== void 0 ? _c : 2,
-        lineColor: (options === null || options === void 0 ? void 0 : options.lineColor) || 'rgba(200,200,200,0.7)',
-        lineWidth: (_d = options === null || options === void 0 ? void 0 : options.lineWidth) !== null && _d !== void 0 ? _d : 1,
-        updateInterval: (_e = options === null || options === void 0 ? void 0 : options.updateInterval) !== null && _e !== void 0 ? _e : 0, // Default update every frame
-        fadeInDuration: (_f = options === null || options === void 0 ? void 0 : options.fadeInDuration) !== null && _f !== void 0 ? _f : 300, // Fade-in duration
+        fontSize: options?.fontSize || '12px',
+        color: options?.color || '#ffffff',
+        background: options?.background || '#1890ff',
+        padding: options?.padding || '6px 10px',
+        borderRadius: options?.borderRadius || '6px',
+        lift: options?.lift ?? 100,
+        dotSize: options?.dotSize ?? 6,
+        dotSpacing: options?.dotSpacing ?? 2,
+        lineColor: options?.lineColor || 'rgba(200,200,200,0.7)',
+        lineWidth: options?.lineWidth ?? 1,
+        updateInterval: options?.updateInterval ?? 0, // Default update every frame
+        fadeInDuration: options?.fadeInDuration ?? 300, // Fade-in duration
     };
     const container = document.createElement('div');
     container.style.position = 'absolute';
@@ -2271,7 +2335,7 @@ function createModelsLabel(camera, renderer, parentModel, modelLabelsMap, option
     svg.style.zIndex = '1';
     container.appendChild(svg);
     let currentModel = parentModel;
-    let currentLabelsMap = Object.assign({}, modelLabelsMap);
+    let currentLabelsMap = { ...modelLabelsMap };
     let labels = [];
     let isActive = true;
     let isPaused = false;
@@ -2352,9 +2416,8 @@ function createModelsLabel(camera, renderer, parentModel, modelLabelsMap, option
         if (!currentModel)
             return;
         currentModel.traverse((child) => {
-            var _a;
             if (child.isMesh || child.type === 'Group') {
-                const labelText = (_a = Object.entries(currentLabelsMap).find(([key]) => child.name.includes(key))) === null || _a === void 0 ? void 0 : _a[1];
+                const labelText = Object.entries(currentLabelsMap).find(([key]) => child.name.includes(key))?.[1];
                 if (!labelText)
                     return;
                 const wrapper = document.createElement('div');
@@ -2459,7 +2522,7 @@ function createModelsLabel(camera, renderer, parentModel, modelLabelsMap, option
             rebuildLabels();
         },
         updateLabelsMap(newMap) {
-            currentLabelsMap = Object.assign({}, newMap);
+            currentLabelsMap = { ...newMap };
             rebuildLabels();
         },
         // Pause update
@@ -2557,205 +2620,197 @@ class GroupExploder {
      * @param newSet The new set of meshes
      * @param contextId Optional context ID to distinguish business scenarios
      */
-    setMeshes(newSet, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const autoRestorePrev = (_a = options === null || options === void 0 ? void 0 : options.autoRestorePrev) !== null && _a !== void 0 ? _a : true;
-            const restoreDuration = (_b = options === null || options === void 0 ? void 0 : options.restoreDuration) !== null && _b !== void 0 ? _b : 300;
-            this.log(`setMeshes called. newSetSize=${newSet ? newSet.size : 0}, autoRestorePrev=${autoRestorePrev}`);
-            // If the newSet is null and currentSet is null -> nothing
-            if (!newSet && !this.currentSet) {
-                this.log('setMeshes: both newSet and currentSet are null, nothing to do');
-                return;
-            }
-            // If both exist and are the same reference, we still must detect content changes.
-            const sameReference = this.currentSet === newSet;
-            // Prepare prevSet snapshot (we copy current to prev)
-            if (this.currentSet) {
-                this.prevSet = this.currentSet;
-                this.prevStateMap = new Map(this.stateMap);
-                this.log(`setMeshes: backed up current->prev prevSetSize=${this.prevSet.size}`);
-            }
-            else {
-                this.prevSet = null;
-                this.prevStateMap = new Map();
-            }
-            // If we used to be exploded and need to restore prevSet, do that first (await)
-            if (this.prevSet && autoRestorePrev && this.isExploded) {
-                this.log('setMeshes: need to restore prevSet before applying newSet');
-                yield this.restoreSet(this.prevSet, this.prevStateMap, restoreDuration, { debug: true });
-                this.log('setMeshes: prevSet restore done');
-                this.prevStateMap.clear();
-                this.prevSet = null;
-            }
-            // Now register newSet: we clear and rebuild stateMap carefully.
-            // But we must handle the case where caller reuses same Set object and just mutated elements.
-            // We will compute additions and removals.
-            const oldSet = this.currentSet;
-            this.currentSet = newSet;
-            // If newSet is null -> simply clear stateMap
-            if (!this.currentSet) {
-                this.stateMap.clear();
-                this.log('setMeshes: newSet is null -> cleared stateMap');
-                this.isExploded = false;
+    async setMeshes(newSet, options) {
+        const autoRestorePrev = options?.autoRestorePrev ?? true;
+        const restoreDuration = options?.restoreDuration ?? 300;
+        this.log(`setMeshes called. newSetSize=${newSet ? newSet.size : 0}, autoRestorePrev=${autoRestorePrev}`);
+        // If the newSet is null and currentSet is null -> nothing
+        if (!newSet && !this.currentSet) {
+            this.log('setMeshes: both newSet and currentSet are null, nothing to do');
+            return;
+        }
+        // If both exist and are the same reference, we still must detect content changes.
+        const sameReference = this.currentSet === newSet;
+        // Prepare prevSet snapshot (we copy current to prev)
+        if (this.currentSet) {
+            this.prevSet = this.currentSet;
+            this.prevStateMap = new Map(this.stateMap);
+            this.log(`setMeshes: backed up current->prev prevSetSize=${this.prevSet.size}`);
+        }
+        else {
+            this.prevSet = null;
+            this.prevStateMap = new Map();
+        }
+        // If we used to be exploded and need to restore prevSet, do that first (await)
+        if (this.prevSet && autoRestorePrev && this.isExploded) {
+            this.log('setMeshes: need to restore prevSet before applying newSet');
+            await this.restoreSet(this.prevSet, this.prevStateMap, restoreDuration, { debug: true });
+            this.log('setMeshes: prevSet restore done');
+            this.prevStateMap.clear();
+            this.prevSet = null;
+        }
+        // Now register newSet: we clear and rebuild stateMap carefully.
+        // But we must handle the case where caller reuses same Set object and just mutated elements.
+        // We will compute additions and removals.
+        const oldSet = this.currentSet;
+        this.currentSet = newSet;
+        // If newSet is null -> simply clear stateMap
+        if (!this.currentSet) {
+            this.stateMap.clear();
+            this.log('setMeshes: newSet is null -> cleared stateMap');
+            this.isExploded = false;
+            return;
+        }
+        // If we have oldSet (could be same reference) then compute diffs
+        if (oldSet) {
+            // If same reference but size or content differs -> handle diffs
+            const wasSameRef = sameReference;
+            let added = [];
+            let removed = [];
+            // Build maps of membership
+            const oldMembers = new Set(Array.from(oldSet));
+            const newMembers = new Set(Array.from(this.currentSet));
+            // find removals
+            oldMembers.forEach((m) => {
+                if (!newMembers.has(m))
+                    removed.push(m);
+            });
+            // find additions
+            newMembers.forEach((m) => {
+                if (!oldMembers.has(m))
+                    added.push(m);
+            });
+            if (wasSameRef && added.length === 0 && removed.length === 0) {
+                // truly identical (no content changes)
+                this.log('setMeshes: same reference and identical contents -> nothing to update');
                 return;
             }
-            // If we have oldSet (could be same reference) then compute diffs
-            if (oldSet) {
-                // If same reference but size or content differs -> handle diffs
-                const wasSameRef = sameReference;
-                let added = [];
-                let removed = [];
-                // Build maps of membership
-                const oldMembers = new Set(Array.from(oldSet));
-                const newMembers = new Set(Array.from(this.currentSet));
-                // find removals
-                oldMembers.forEach((m) => {
-                    if (!newMembers.has(m))
-                        removed.push(m);
-                });
-                // find additions
-                newMembers.forEach((m) => {
-                    if (!oldMembers.has(m))
-                        added.push(m);
-                });
-                if (wasSameRef && added.length === 0 && removed.length === 0) {
-                    // truly identical (no content changes)
-                    this.log('setMeshes: same reference and identical contents -> nothing to update');
-                    return;
+            this.log(`setMeshes: diff detected -> added=${added.length}, removed=${removed.length}`);
+            // Remove snapshots for removed meshes
+            removed.forEach((m) => {
+                if (this.stateMap.has(m)) {
+                    this.stateMap.delete(m);
                 }
-                this.log(`setMeshes: diff detected -> added=${added.length}, removed=${removed.length}`);
-                // Remove snapshots for removed meshes
-                removed.forEach((m) => {
-                    if (this.stateMap.has(m)) {
-                        this.stateMap.delete(m);
-                    }
-                });
-                // Ensure snapshots exist for current set members (create for newly added meshes)
-                yield this.ensureSnapshotsForSet(this.currentSet);
-                this.log(`setMeshes: after diff handling, stateMap size=${this.stateMap.size}`);
-                this.isExploded = false;
-                return;
-            }
-            else {
-                // no oldSet -> brand new registration
-                this.stateMap.clear();
-                yield this.ensureSnapshotsForSet(this.currentSet);
-                this.log(`setMeshes: recorded stateMap entries for newSet size=${this.stateMap.size}`);
-                this.isExploded = false;
-                return;
-            }
-        });
+            });
+            // Ensure snapshots exist for current set members (create for newly added meshes)
+            await this.ensureSnapshotsForSet(this.currentSet);
+            this.log(`setMeshes: after diff handling, stateMap size=${this.stateMap.size}`);
+            this.isExploded = false;
+            return;
+        }
+        else {
+            // no oldSet -> brand new registration
+            this.stateMap.clear();
+            await this.ensureSnapshotsForSet(this.currentSet);
+            this.log(`setMeshes: recorded stateMap entries for newSet size=${this.stateMap.size}`);
+            this.isExploded = false;
+            return;
+        }
     }
     /**
      * ensureSnapshotsForSet: for each mesh in set, ensure stateMap has an entry.
      * If missing, record current matrixWorld as originalMatrixWorld (best-effort).
      */
-    ensureSnapshotsForSet(set) {
-        return __awaiter(this, void 0, void 0, function* () {
-            set.forEach((m) => {
+    async ensureSnapshotsForSet(set) {
+        set.forEach((m) => {
+            try {
+                m.updateMatrixWorld(true);
+            }
+            catch { }
+            if (!this.stateMap.has(m)) {
                 try {
-                    m.updateMatrixWorld(true);
+                    this.stateMap.set(m, {
+                        originalParent: m.parent || null,
+                        originalMatrixWorld: (m.matrixWorld && m.matrixWorld.clone()) || new THREE__namespace.Matrix4().copy(m.matrix),
+                    });
+                    // Also store in userData for extra resilience
+                    m.userData.__originalMatrixWorld = this.stateMap.get(m).originalMatrixWorld.clone();
                 }
-                catch (_a) { }
-                if (!this.stateMap.has(m)) {
-                    try {
-                        this.stateMap.set(m, {
-                            originalParent: m.parent || null,
-                            originalMatrixWorld: (m.matrixWorld && m.matrixWorld.clone()) || new THREE__namespace.Matrix4().copy(m.matrix),
-                        });
-                        // Also store in userData for extra resilience
-                        m.userData.__originalMatrixWorld = this.stateMap.get(m).originalMatrixWorld.clone();
-                    }
-                    catch (e) {
-                        this.log(`ensureSnapshotsForSet: failed to snapshot mesh ${m.name || m.id}: ${e.message}`);
-                    }
+                catch (e) {
+                    this.log(`ensureSnapshotsForSet: failed to snapshot mesh ${m.name || m.id}: ${e.message}`);
                 }
-            });
+            }
         });
     }
     /**
      * explode: compute targets first, compute targetBound using targets + mesh radii,
      * animate camera to that targetBound, then animate meshes to targets.
      */
-    explode(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!this.currentSet || this.currentSet.size === 0) {
-                this.log('explode: empty currentSet, nothing to do');
-                return;
+    async explode(opts) {
+        if (!this.currentSet || this.currentSet.size === 0) {
+            this.log('explode: empty currentSet, nothing to do');
+            return;
+        }
+        const { spacing = 2, duration = 1000, lift = 0.5, cameraPadding = 1.5, mode = 'spiral', dimOthers = { enabled: true, opacity: 0.25 }, debug = false, } = opts || {};
+        this.log(`explode called. setSize=${this.currentSet.size}, mode=${mode}, spacing=${spacing}, duration=${duration}, lift=${lift}, dim=${dimOthers.enabled}`);
+        this.cancelAnimations();
+        const meshes = Array.from(this.currentSet);
+        // ensure snapshots exist for any meshes that may have been added after initial registration
+        await this.ensureSnapshotsForSet(this.currentSet);
+        // compute center/radius from current meshes (fallback)
+        const initial = this.computeBoundingSphereForMeshes(meshes);
+        const center = initial.center;
+        const baseRadius = Math.max(1, initial.radius);
+        this.log(`explode: initial center=${center.toArray().map((n) => n.toFixed(3))}, baseRadius=${baseRadius.toFixed(3)}`);
+        // compute targets (pure calculation)
+        const targets = this.computeTargetsByMode(meshes, center, baseRadius + spacing, { lift, mode });
+        this.log(`explode: computed ${targets.length} target positions`);
+        // compute target-based bounding sphere (targets + per-mesh radius)
+        const targetBound = this.computeBoundingSphereForPositionsAndMeshes(targets, meshes);
+        this.log(`explode: targetBound center=${targetBound.center.toArray().map((n) => n.toFixed(3))}, radius=${targetBound.radius.toFixed(3)}`);
+        await this.animateCameraToFit(targetBound.center, targetBound.radius, { duration: Math.min(600, duration), padding: cameraPadding });
+        this.log('explode: camera animation to target bound completed');
+        // apply dim if needed with context id
+        const contextId = dimOthers?.enabled ? this.applyDimToOthers(meshes, dimOthers.opacity ?? 0.25, { debug }) : null;
+        if (contextId)
+            this.log(`explode: applied dim for context ${contextId}`);
+        // capture starts after camera move
+        const starts = meshes.map((m) => {
+            const v = new THREE__namespace.Vector3();
+            try {
+                m.getWorldPosition(v);
             }
-            const { spacing = 2, duration = 1000, lift = 0.5, cameraPadding = 1.5, mode = 'spiral', dimOthers = { enabled: true, opacity: 0.25 }, debug = false, } = opts || {};
-            this.log(`explode called. setSize=${this.currentSet.size}, mode=${mode}, spacing=${spacing}, duration=${duration}, lift=${lift}, dim=${dimOthers.enabled}`);
-            this.cancelAnimations();
-            const meshes = Array.from(this.currentSet);
-            // ensure snapshots exist for any meshes that may have been added after initial registration
-            yield this.ensureSnapshotsForSet(this.currentSet);
-            // compute center/radius from current meshes (fallback)
-            const initial = this.computeBoundingSphereForMeshes(meshes);
-            const center = initial.center;
-            const baseRadius = Math.max(1, initial.radius);
-            this.log(`explode: initial center=${center.toArray().map((n) => n.toFixed(3))}, baseRadius=${baseRadius.toFixed(3)}`);
-            // compute targets (pure calculation)
-            const targets = this.computeTargetsByMode(meshes, center, baseRadius + spacing, { lift, mode });
-            this.log(`explode: computed ${targets.length} target positions`);
-            // compute target-based bounding sphere (targets + per-mesh radius)
-            const targetBound = this.computeBoundingSphereForPositionsAndMeshes(targets, meshes);
-            this.log(`explode: targetBound center=${targetBound.center.toArray().map((n) => n.toFixed(3))}, radius=${targetBound.radius.toFixed(3)}`);
-            yield this.animateCameraToFit(targetBound.center, targetBound.radius, { duration: Math.min(600, duration), padding: cameraPadding });
-            this.log('explode: camera animation to target bound completed');
-            // apply dim if needed with context id
-            const contextId = (dimOthers === null || dimOthers === void 0 ? void 0 : dimOthers.enabled) ? this.applyDimToOthers(meshes, (_a = dimOthers.opacity) !== null && _a !== void 0 ? _a : 0.25, { debug }) : null;
-            if (contextId)
-                this.log(`explode: applied dim for context ${contextId}`);
-            // capture starts after camera move
-            const starts = meshes.map((m) => {
-                const v = new THREE__namespace.Vector3();
-                try {
-                    m.getWorldPosition(v);
-                }
-                catch (_a) {
-                    // fallback to originalMatrixWorld if available
-                    const st = this.stateMap.get(m);
-                    if (st)
-                        v.setFromMatrixPosition(st.originalMatrixWorld);
-                }
-                return v;
-            });
-            const startTime = performance.now();
-            const total = Math.max(1, duration);
-            const tick = (now) => {
-                const t = Math.min(1, (now - startTime) / total);
-                const eased = easeInOutQuad(t);
-                for (let i = 0; i < meshes.length; i++) {
-                    const m = meshes[i];
-                    const s = starts[i];
-                    const tar = targets[i];
-                    const cur = s.clone().lerp(tar, eased);
-                    if (m.parent) {
-                        const local = cur.clone();
-                        m.parent.worldToLocal(local);
-                        m.position.copy(local);
-                    }
-                    else {
-                        m.position.copy(cur);
-                    }
-                    m.updateMatrix();
-                }
-                if (this.controls && typeof this.controls.update === 'function')
-                    this.controls.update();
-                if (t < 1) {
-                    this.animId = requestAnimationFrame(tick);
+            catch {
+                // fallback to originalMatrixWorld if available
+                const st = this.stateMap.get(m);
+                if (st)
+                    v.setFromMatrixPosition(st.originalMatrixWorld);
+            }
+            return v;
+        });
+        const startTime = performance.now();
+        const total = Math.max(1, duration);
+        const tick = (now) => {
+            const t = Math.min(1, (now - startTime) / total);
+            const eased = easeInOutQuad(t);
+            for (let i = 0; i < meshes.length; i++) {
+                const m = meshes[i];
+                const s = starts[i];
+                const tar = targets[i];
+                const cur = s.clone().lerp(tar, eased);
+                if (m.parent) {
+                    const local = cur.clone();
+                    m.parent.worldToLocal(local);
+                    m.position.copy(local);
                 }
                 else {
-                    this.animId = null;
-                    this.isExploded = true;
-                    this.log(`explode: completed. contextId=${contextId !== null && contextId !== void 0 ? contextId : 'none'}`);
+                    m.position.copy(cur);
                 }
-            };
-            this.animId = requestAnimationFrame(tick);
-            return;
-        });
+                m.updateMatrix();
+            }
+            if (this.controls && typeof this.controls.update === 'function')
+                this.controls.update();
+            if (t < 1) {
+                this.animId = requestAnimationFrame(tick);
+            }
+            else {
+                this.animId = null;
+                this.isExploded = true;
+                this.log(`explode: completed. contextId=${contextId ?? 'none'}`);
+            }
+        };
+        this.animId = requestAnimationFrame(tick);
+        return;
     }
     /**
      * Restore all exploded meshes to their original transform:
@@ -2778,7 +2833,7 @@ class GroupExploder {
      */
     restoreSet(set, stateMap, duration = 400, opts) {
         if (!set || set.size === 0) {
-            if (opts === null || opts === void 0 ? void 0 : opts.debug)
+            if (opts?.debug)
                 this.log('restoreSet: empty set, nothing to restore');
             return Promise.resolve();
         }
@@ -2791,12 +2846,12 @@ class GroupExploder {
             try {
                 m.updateMatrixWorld(true);
             }
-            catch (_a) { }
+            catch { }
             const s = new THREE__namespace.Vector3();
             try {
                 m.getWorldPosition(s);
             }
-            catch (_b) {
+            catch {
                 s.set(0, 0, 0);
             }
             starts.push(s);
@@ -2894,7 +2949,7 @@ class GroupExploder {
         });
     }
     // material dim with context id
-    applyDimToOthers(explodingMeshes, opacity = 0.25, opts) {
+    applyDimToOthers(explodingMeshes, opacity = 0.25, _opts) {
         const contextId = `ctx_${Date.now()}_${Math.floor(Math.random() * 10000)}`;
         const explodingSet = new Set(explodingMeshes);
         const touched = new Set();
@@ -2905,11 +2960,10 @@ class GroupExploder {
             if (explodingSet.has(mesh))
                 return;
             const applyMat = (mat) => {
-                var _a;
                 if (!this.materialSnaps.has(mat)) {
                     this.materialSnaps.set(mat, {
                         transparent: !!mat.transparent,
-                        opacity: (_a = mat.opacity) !== null && _a !== void 0 ? _a : 1,
+                        opacity: mat.opacity ?? 1,
                         depthWrite: mat.depthWrite,
                     });
                 }
@@ -2936,7 +2990,7 @@ class GroupExploder {
         return contextId;
     }
     // clean contexts for meshes (restore materials whose contexts are removed)
-    cleanContextsForMeshes(meshes) {
+    cleanContextsForMeshes(_meshes) {
         // conservative strategy: for each context we created, delete it and restore materials accordingly
         for (const [contextId, mats] of Array.from(this.contextMaterials.entries())) {
             mats.forEach((mat) => {
@@ -3050,7 +3104,7 @@ class GroupExploder {
                     }
                 }
             }
-            catch (_a) {
+            catch {
                 radius = 0;
             }
             if (!isFinite(radius) || radius < 0 || radius > 1e8)
@@ -3073,10 +3127,9 @@ class GroupExploder {
     }
     // computeTargetsByMode (unchanged logic but pure function)
     computeTargetsByMode(meshes, center, baseRadius, opts) {
-        var _a, _b;
         const n = meshes.length;
-        const lift = (_a = opts.lift) !== null && _a !== void 0 ? _a : 0.5;
-        const mode = (_b = opts.mode) !== null && _b !== void 0 ? _b : 'ring';
+        const lift = opts.lift ?? 0.5;
+        const mode = opts.mode ?? 'ring';
         const targets = [];
         if (mode === 'ring') {
             for (let i = 0; i < n; i++) {
@@ -3118,9 +3171,8 @@ class GroupExploder {
         return targets;
     }
     animateCameraToFit(targetCenter, targetRadius, opts) {
-        var _a, _b, _c, _d;
-        const duration = (_a = opts === null || opts === void 0 ? void 0 : opts.duration) !== null && _a !== void 0 ? _a : 600;
-        const padding = (_b = opts === null || opts === void 0 ? void 0 : opts.padding) !== null && _b !== void 0 ? _b : 1.5;
+        const duration = opts?.duration ?? 600;
+        const padding = opts?.padding ?? 1.5;
         if (!(this.camera instanceof THREE__namespace.PerspectiveCamera)) {
             if (this.controls && this.controls.target) {
                 // Fallback for non-PerspectiveCamera
@@ -3132,14 +3184,13 @@ class GroupExploder {
                 const endPos = endTarget.clone().add(dir.multiplyScalar(dist));
                 const startTime = performance.now();
                 const tick = (now) => {
-                    var _a;
                     const t = Math.min(1, (now - startTime) / duration);
                     const k = easeInOutQuad(t);
                     if (this.controls && this.controls.target) {
                         this.controls.target.lerpVectors(startTarget, endTarget, k);
                     }
                     this.camera.position.lerpVectors(startPos, endPos, k);
-                    if ((_a = this.controls) === null || _a === void 0 ? void 0 : _a.update)
+                    if (this.controls?.update)
                         this.controls.update();
                     if (t < 1) {
                         this.cameraAnimId = requestAnimationFrame(tick);
@@ -3162,8 +3213,8 @@ class GroupExploder {
         const distH = targetRadius / Math.sin(Math.min(fov, fov * aspect) / 2); // approximate
         const dist = Math.max(distV, distH) * padding;
         const startPos = this.camera.position.clone();
-        const startTarget = ((_c = this.controls) === null || _c === void 0 ? void 0 : _c.target) ? this.controls.target.clone() : new THREE__namespace.Vector3(); // assumption
-        if (!((_d = this.controls) === null || _d === void 0 ? void 0 : _d.target)) {
+        const startTarget = this.controls?.target ? this.controls.target.clone() : new THREE__namespace.Vector3(); // assumption
+        if (!this.controls?.target) {
             this.camera.getWorldDirection(startTarget);
             startTarget.add(startPos);
         }
@@ -3176,13 +3227,12 @@ class GroupExploder {
         return new Promise((resolve) => {
             const startTime = performance.now();
             const tick = (now) => {
-                var _a, _b;
                 const t = Math.min(1, (now - startTime) / duration);
                 const k = easeInOutQuad(t);
                 this.camera.position.lerpVectors(startPos, endPos, k);
                 if (this.controls && this.controls.target) {
                     this.controls.target.lerpVectors(startTarget, endTarget, k);
-                    (_b = (_a = this.controls).update) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    this.controls.update?.();
                 }
                 else {
                     this.camera.lookAt(endTarget); // simple lookAt if no controls
@@ -3231,183 +3281,134 @@ class GroupExploder {
  * @file autoSetup.ts
  * @description
  * Automatically sets up the camera and basic lighting scene based on the model's bounding box.
- *
- * @best-practice
- * - Call `autoSetupCameraAndLight` after loading a model to get a quick "good looking" scene.
- * - Returns a handle to dispose lights or update intensity later.
  */
 /**
- * Automatically setup camera and basic lighting - Optimized
- *
- * Features:
- * - Adds light intensity adjustment method
- * - Improved error handling
- * - Optimized dispose logic
- *
- * - camera: THREE.PerspectiveCamera (will be moved and pointed at model center)
- * - scene: THREE.Scene (newly created light group will be added to the scene)
- * - model: THREE.Object3D loaded model (arbitrary transform/coordinates)
- * - options: Optional configuration (see AutoSetupOptions)
- *
- * Returns AutoSetupHandle, caller should call handle.dispose() when component unmounts/switches
+ * Fit camera to object bounding box
  */
-function autoSetupCameraAndLight(camera, scene, model, options = {}) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    // Boundary check
-    if (!camera || !scene || !model) {
-        throw new Error('autoSetupCameraAndLight: camera, scene, model are required');
-    }
+function fitCameraToObject(camera, object, padding = 1.2, elevation = 0.2) {
+    const box = new THREE__namespace.Box3().setFromObject(object);
+    if (!isFinite(box.min.x))
+        return { center: new THREE__namespace.Vector3(), radius: 0 };
+    const sphere = new THREE__namespace.Sphere();
+    box.getBoundingSphere(sphere);
+    const center = sphere.center.clone();
+    const radius = Math.max(0.001, sphere.radius);
+    const fov = (camera.fov * Math.PI) / 180;
+    const halfFov = fov / 2;
+    const sinHalfFov = Math.max(Math.sin(halfFov), 0.001);
+    const distance = (radius * padding) / sinHalfFov;
+    const dir = new THREE__namespace.Vector3(0, Math.sin(elevation), Math.cos(elevation)).normalize();
+    const desiredPos = center.clone().add(dir.multiplyScalar(distance));
+    camera.position.copy(desiredPos);
+    camera.lookAt(center);
+    camera.near = Math.max(0.001, radius / 1000);
+    camera.far = Math.max(1000, radius * 50);
+    camera.updateProjectionMatrix();
+    return { center, radius };
+}
+/**
+ * Setup default lighting for a model
+ */
+function setupDefaultLights(scene, model, options = {}) {
+    const box = new THREE__namespace.Box3().setFromObject(model);
+    const sphere = new THREE__namespace.Sphere();
+    box.getBoundingSphere(sphere);
+    const center = sphere.center.clone();
+    const radius = Math.max(0.001, sphere.radius);
     const opts = {
-        padding: (_a = options.padding) !== null && _a !== void 0 ? _a : 1.2,
-        elevation: (_b = options.elevation) !== null && _b !== void 0 ? _b : 0.2,
-        enableShadows: (_c = options.enableShadows) !== null && _c !== void 0 ? _c : false,
-        shadowMapSize: (_d = options.shadowMapSize) !== null && _d !== void 0 ? _d : 1024,
-        directionalCount: (_e = options.directionalCount) !== null && _e !== void 0 ? _e : 4,
-        setMeshShadowProps: (_f = options.setMeshShadowProps) !== null && _f !== void 0 ? _f : true,
-        renderer: (_g = options.renderer) !== null && _g !== void 0 ? _g : null,
+        padding: options.padding ?? 1.2,
+        elevation: options.elevation ?? 0.2,
+        enableShadows: options.enableShadows ?? false,
+        shadowMapSize: options.shadowMapSize ?? 1024,
+        directionalCount: options.directionalCount ?? 4,
+        setMeshShadowProps: options.setMeshShadowProps ?? true,
+        renderer: options.renderer ?? null,
     };
-    try {
-        // --- 1) Calculate bounding data
-        const box = new THREE__namespace.Box3().setFromObject(model);
-        // Check bounding box validity
-        if (!isFinite(box.min.x)) {
-            throw new Error('autoSetupCameraAndLight: Invalid bounding box');
+    if (opts.renderer && opts.enableShadows) {
+        opts.renderer.shadowMap.enabled = true;
+        opts.renderer.shadowMap.type = THREE__namespace.PCFSoftShadowMap;
+    }
+    const lightsGroup = new THREE__namespace.Group();
+    lightsGroup.name = 'autoSetupLightsGroup';
+    lightsGroup.position.copy(center);
+    scene.add(lightsGroup);
+    const hemi = new THREE__namespace.HemisphereLight(0xffffff, 0x444444, 0.6);
+    hemi.position.set(0, radius * 2.0, 0);
+    lightsGroup.add(hemi);
+    const ambient = new THREE__namespace.AmbientLight(0xffffff, 0.25);
+    lightsGroup.add(ambient);
+    const dirCount = Math.max(1, Math.floor(opts.directionalCount));
+    const dirs = [new THREE__namespace.Vector3(0, 1, 0)];
+    for (let i = 0; i < dirCount; i++) {
+        const angle = (i / dirCount) * Math.PI * 2;
+        const v = new THREE__namespace.Vector3(Math.cos(angle), 0.3, Math.sin(angle)).normalize();
+        dirs.push(v);
+    }
+    const shadowCamSize = Math.max(1, radius * 1.5);
+    dirs.forEach((d, i) => {
+        const light = new THREE__namespace.DirectionalLight(0xffffff, i === 0 ? 1.5 : 1.2);
+        light.position.copy(d.clone().multiplyScalar(radius * 2.5));
+        light.target.position.copy(center);
+        light.name = `auto_dir_${i}`;
+        lightsGroup.add(light);
+        lightsGroup.add(light.target);
+        if (opts.enableShadows) {
+            light.castShadow = true;
+            light.shadow.mapSize.width = opts.shadowMapSize;
+            light.shadow.mapSize.height = opts.shadowMapSize;
+            const cam = light.shadow.camera;
+            const s = shadowCamSize;
+            cam.left = -s;
+            cam.right = s;
+            cam.top = s;
+            cam.bottom = -s;
+            cam.near = 0.1;
+            cam.far = radius * 10 + 50;
+            light.shadow.bias = -5e-4;
         }
-        const sphere = new THREE__namespace.Sphere();
-        box.getBoundingSphere(sphere);
-        const center = sphere.center.clone();
-        const radius = Math.max(0.001, sphere.radius);
-        // --- 2) Calculate camera position
-        const fov = (camera.fov * Math.PI) / 180;
-        const halfFov = fov / 2;
-        const sinHalfFov = Math.max(Math.sin(halfFov), 0.001);
-        const distance = (radius * opts.padding) / sinHalfFov;
-        const dir = new THREE__namespace.Vector3(0, Math.sin(opts.elevation), Math.cos(opts.elevation)).normalize();
-        const desiredPos = center.clone().add(dir.multiplyScalar(distance));
-        camera.position.copy(desiredPos);
-        camera.lookAt(center);
-        camera.near = Math.max(0.001, radius / 1000);
-        camera.far = Math.max(1000, radius * 50);
-        camera.updateProjectionMatrix();
-        // --- 3) Enable Shadows
-        if (opts.renderer && opts.enableShadows) {
-            opts.renderer.shadowMap.enabled = true;
-            opts.renderer.shadowMap.type = THREE__namespace.PCFSoftShadowMap;
-        }
-        // --- 4) Create Lights Group
-        const lightsGroup = new THREE__namespace.Group();
-        lightsGroup.name = 'autoSetupLightsGroup';
-        lightsGroup.position.copy(center);
-        scene.add(lightsGroup);
-        // 4.1 Basic Light
-        const hemi = new THREE__namespace.HemisphereLight(0xffffff, 0x444444, 0.6);
-        hemi.name = 'auto_hemi';
-        hemi.position.set(0, radius * 2.0, 0);
-        lightsGroup.add(hemi);
-        const ambient = new THREE__namespace.AmbientLight(0xffffff, 0.25);
-        ambient.name = 'auto_ambient';
-        lightsGroup.add(ambient);
-        // 4.2 Directional Lights
-        const dirCount = Math.max(1, Math.floor(opts.directionalCount));
-        const directionalLights = [];
-        const dirs = [];
-        dirs.push(new THREE__namespace.Vector3(0, 1, 0));
-        for (let i = 0; i < Math.max(1, dirCount); i++) {
-            const angle = (i / Math.max(1, dirCount)) * Math.PI * 2;
-            const v = new THREE__namespace.Vector3(Math.cos(angle), 0.3, Math.sin(angle)).normalize();
-            dirs.push(v);
-        }
-        const shadowCamSize = Math.max(1, radius * 1.5);
-        for (let i = 0; i < dirs.length; i++) {
-            const d = dirs[i];
-            const light = new THREE__namespace.DirectionalLight(0xffffff, i === 0 ? 1.5 : 1.2);
-            light.position.copy(d.clone().multiplyScalar(radius * 2.5));
-            light.target.position.copy(center);
-            light.name = `auto_dir_${i}`;
-            lightsGroup.add(light);
-            lightsGroup.add(light.target);
-            if (opts.enableShadows) {
-                light.castShadow = true;
-                light.shadow.mapSize.width = opts.shadowMapSize;
-                light.shadow.mapSize.height = opts.shadowMapSize;
-                const cam = light.shadow.camera;
-                const s = shadowCamSize;
-                cam.left = -s;
-                cam.right = s;
-                cam.top = s;
-                cam.bottom = -s;
-                cam.near = 0.1;
-                cam.far = radius * 10 + 50;
-                light.shadow.bias = -0.0005;
-            }
-            directionalLights.push(light);
-        }
-        // 4.3 Point Light Fill
-        const fill1 = new THREE__namespace.PointLight(0xffffff, 0.5, radius * 4);
-        fill1.position.copy(center).add(new THREE__namespace.Vector3(radius * 0.5, 0.2 * radius, 0));
-        fill1.name = 'auto_fill1';
-        lightsGroup.add(fill1);
-        const fill2 = new THREE__namespace.PointLight(0xffffff, 0.3, radius * 3);
-        fill2.position.copy(center).add(new THREE__namespace.Vector3(-radius * 0.5, -0.2 * radius, 0));
-        fill2.name = 'auto_fill2';
-        lightsGroup.add(fill2);
-        // --- 5) Set Mesh Shadow Props
-        if (opts.setMeshShadowProps) {
-            model.traverse((ch) => {
-                if (ch.isMesh) {
-                    const mesh = ch;
-                    const isSkinned = mesh.isSkinnedMesh;
-                    mesh.castShadow = opts.enableShadows && !isSkinned ? true : mesh.castShadow;
-                    mesh.receiveShadow = opts.enableShadows ? true : mesh.receiveShadow;
+    });
+    if (opts.setMeshShadowProps) {
+        model.traverse((ch) => {
+            if (ch.isMesh) {
+                const mesh = ch;
+                const isSkinned = mesh.isSkinnedMesh;
+                mesh.castShadow = opts.enableShadows && !isSkinned ? true : mesh.castShadow;
+                mesh.receiveShadow = opts.enableShadows ? true : mesh.receiveShadow;
+            }
+        });
+    }
+    const handle = {
+        lightsGroup,
+        center,
+        radius,
+        updateLightIntensity(factor) {
+            lightsGroup.traverse((node) => {
+                if (node.isLight) {
+                    const light = node;
+                    light.intensity *= factor; // Simple implementation
                 }
             });
-        }
-        // --- 6) Return handle ---
-        const handle = {
-            lightsGroup,
-            center,
-            radius,
-            // Update light intensity
-            updateLightIntensity(factor) {
-                lightsGroup.traverse((node) => {
-                    if (node.isLight) {
-                        const light = node;
-                        const originalIntensity = parseFloat(light.name.split('_').pop() || '1');
-                        light.intensity = originalIntensity * Math.max(0, factor);
-                    }
-                });
-            },
-            dispose: () => {
-                try {
-                    // Remove lights group
-                    if (lightsGroup.parent)
-                        lightsGroup.parent.remove(lightsGroup);
-                    // Dispose shadow resources
-                    lightsGroup.traverse((node) => {
-                        if (node.isLight) {
-                            const l = node;
-                            if (l.shadow && l.shadow.map) {
-                                try {
-                                    l.shadow.map.dispose();
-                                }
-                                catch (err) {
-                                    console.warn('Failed to dispose shadow map:', err);
-                                }
-                            }
-                        }
-                    });
-                }
-                catch (error) {
-                    console.error('autoSetupCameraAndLight: dispose failed', error);
+        },
+        dispose: () => {
+            if (lightsGroup.parent)
+                lightsGroup.parent.remove(lightsGroup);
+            lightsGroup.traverse((node) => {
+                if (node.isLight) {
+                    const l = node;
+                    if (l.shadow && l.shadow.map)
+                        l.shadow.map.dispose();
                 }
-            }
-        };
-        return handle;
-    }
-    catch (error) {
-        console.error('autoSetupCameraAndLight: setup failed', error);
-        throw error;
-    }
+            });
+        }
+    };
+    return handle;
+}
+/**
+ * Automatically setup camera and basic lighting (Combine fitCameraToObject and setupDefaultLights)
+ */
+function autoSetupCameraAndLight(camera, scene, model, options = {}) {
+    fitCameraToObject(camera, model, options.padding, options.elevation);
+    return setupDefaultLights(scene, model, options);
 }
 
 /**
@@ -3417,14 +3418,15 @@ function autoSetupCameraAndLight(camera, scene, model, options = {}) {
  * @packageDocumentation
  */
 // Core utilities
-// Version
-const VERSION = '1.0.0';
+// Version (keep in sync with package.json)
+const VERSION = '1.0.4';
 
 exports.ArrowGuide = ArrowGuide;
 exports.BlueSky = BlueSky;
 exports.FOLLOW_ANGLES = FOLLOW_ANGLES;
 exports.GroupExploder = GroupExploder;
 exports.LiquidFillerGroup = LiquidFillerGroup;
+exports.ResourceManager = ResourceManager;
 exports.VERSION = VERSION;
 exports.ViewPresets = ViewPresets;
 exports.addChildModelLabels = addChildModelLabels;
@@ -3436,12 +3438,16 @@ exports.createModelsLabel = createModelsLabel;
 exports.disposeMaterial = disposeMaterial;
 exports.disposeObject = disposeObject;
 exports.enableHoverBreath = enableHoverBreath;
+exports.fitCameraToObject = fitCameraToObject;
 exports.followModels = followModels;
+exports.getLoaderConfig = getLoaderConfig;
 exports.initPostProcessing = initPostProcessing;
 exports.loadCubeSkybox = loadCubeSkybox;
 exports.loadEquirectSkybox = loadEquirectSkybox;
 exports.loadModelByUrl = loadModelByUrl;
 exports.loadSkybox = loadSkybox;
 exports.releaseSkybox = releaseSkybox;
+exports.setLoaderConfig = setLoaderConfig;
 exports.setView = setView;
+exports.setupDefaultLights = setupDefaultLights;
 //# sourceMappingURL=index.js.map