@preference-sl/pref-viewer 2.16.0-beta.5 → 2.16.0-beta.8

package/src/file-storage.js

@@ -129,10 +129,6 @@ export default class FileStorage {
     #minimumFreeSpaceRatio = 0.05; // try to keep at least 5% of quota free
     #maxQuotaEvictionRetries = 5; // max retries after quota error
     #lastCleanupAt = 0; // timestamp of last automatic cleanup run
-    // In-memory blob cache — eliminates repeated IDB round-trips for the same URI within a session.
-    // Keyed by URI; values are normalized records (blob kept in RAM). Avoids both the readonly read
-    // and the readwrite #touchFile transaction on every getURL() call during #replaceSceneURIAsync.
-    #memoryCache = new Map();
 
     constructor(dbName = "FilesDB", osName = "FilesObjectStore") {
         this.dbName = dbName; // database name
@@ -262,7 +258,6 @@ export default class FileStorage {
         const store = transaction.objectStore(this.osName);
         keys.forEach((key) => {
             store.delete(key);
-            this.#memoryCache.delete(String(key));
         });
         await transaction.done;
         return keys.length;
@@ -613,7 +608,6 @@ export default class FileStorage {
                 const store = transaction.objectStore(this.osName);
                 const result = await store.put(record, uri);
                 await transaction.done;
-                this.#memoryCache.set(uri, record);
                 return result;
             } catch (error) {
                 if (!this.#isQuotaExceededError(error) || attempt === this.#maxQuotaEvictionRetries) {
@@ -641,19 +635,6 @@ export default class FileStorage {
      *   - false: if the database could not be opened (IndexedDB unsupported or open failure)
      */
     async #getFile(uri, { touch = true, allowExpired = false } = {}) {
-        // In-memory cache hit: skip IDB entirely, update lastAccess in RAM only.
-        const inMemory = this.#memoryCache.get(uri);
-        if (inMemory) {
-            if (!allowExpired && this.#isExpired(inMemory)) {
-                this.#memoryCache.delete(uri);
-            } else {
-                if (touch) {
-                    inMemory.lastAccess = this.#now();
-                }
-                return inMemory;
-            }
-        }
-
         if (this.#db === undefined) {
             this.#db = await this.#openDB();
         }
@@ -670,68 +651,13 @@ export default class FileStorage {
             await this.#deleteKeys([uri]);
             return undefined;
         }
-        this.#memoryCache.set(uri, record);
         if (touch) {
-            // Fire-and-forget: don't block the caller on a readwrite IDB transaction just to update lastAccess.
-            void this.#touchFile(uri, record);
+            await this.#touchFile(uri, record);
             record.lastAccess = this.#now();
         }
         return record;
     }
 
-    /**
-     * Retrieves multiple file records from the in-memory cache and IDB in a single readonly
-     * transaction, populating the in-memory cache for all hits.
-     * @private
-     * @param {string[]} uris - URIs to look up.
-     * @returns {Promise<Map<string, object>>} Map of uri → normalized record for found entries.
-     */
-    async #getFileBatch(uris) {
-        const resultMap = new Map();
-        if (!uris.length) return resultMap;
-
-        const idbMisses = [];
-        for (const uri of uris) {
-            const cached = this.#memoryCache.get(uri);
-            if (cached) {
-                if (this.#isExpired(cached)) {
-                    this.#memoryCache.delete(uri);
-                    idbMisses.push(uri);
-                } else {
-                    resultMap.set(uri, cached);
-                }
-            } else {
-                idbMisses.push(uri);
-            }
-        }
-
-        if (!idbMisses.length) return resultMap;
-
-        if (this.#db === undefined) {
-            this.#db = await this.#openDB();
-        }
-        if (this.#db === null) return resultMap;
-
-        // One readonly transaction for all IDB misses — single lock acquisition vs N transactions.
-        const tx = this.#db.transaction(this.osName, "readonly");
-        const store = tx.objectStore(this.osName);
-        const rawRecords = await Promise.all(idbMisses.map((uri) => store.get(uri)));
-
-        const now = this.#now();
-        idbMisses.forEach((uri, i) => {
-            const record = this.#normalizeRecord(rawRecords[i]);
-            if (!record) return;
-            if (this.#isExpired(record, now)) {
-                void this.#deleteKeys([uri]);
-                return;
-            }
-            this.#memoryCache.set(uri, record);
-            resultMap.set(uri, record);
-        });
-
-        return resultMap;
-    }
-
     /**
      * ---------------------------
      * Public methods
@@ -756,44 +682,6 @@ export default class FileStorage {
         return storedFile ? URL.createObjectURL(storedFile.blob) : (await this.#getServerFileTimeStamp(uri)) ? uri : false;
     }
 
-    /**
-     * Resolve multiple URIs to object URLs in a single IDB batch transaction.
-     * Hits in-memory cache first, then IDB in one transaction, then falls back to individual
-     * server downloads for any URIs not found. Returns a Map<uri, objectURL|uri>.
-     * @public
-     * @param {string[]} uris - URIs to resolve.
-     * @returns {Promise<Map<string, string>>} Map of uri → resolved URL (blob: or original URI).
-     */
-    async getURLBatch(uris) {
-        if (!uris.length) return new Map();
-        if (!this.#supported) {
-            return new Map(uris.map((uri) => [uri, uri]));
-        }
-        await this.#runCleanupIfDue();
-        const records = await this.#getFileBatch(uris);
-        const urlMap = new Map();
-        const serverFetches = [];
-
-        for (const uri of uris) {
-            const record = records.get(uri);
-            if (record?.blob) {
-                urlMap.set(uri, URL.createObjectURL(record.blob));
-            } else {
-                serverFetches.push(uri);
-            }
-        }
-
-        // For URIs absent from IDB, fall back to individual get() which downloads and caches them.
-        await Promise.all(
-            serverFetches.map(async (uri) => {
-                const url = await this.getURL(uri);
-                if (url) urlMap.set(uri, url);
-            })
-        );
-
-        return urlMap;
-    }
-
     /**
      * Get the cached or server Last-Modified timestamp for a file.
      * @public
@@ -874,18 +762,10 @@ export default class FileStorage {
         }
         if (!storedFile) {
             const fileToStore = await this.#getServerFile(uri);
-            if (fileToStore) {
-                // Populate in-memory cache immediately after download so subsequent calls
-                // within this session are instant — even if the IDB write fails later.
-                const freshRecord = this.#createRecordFromFile(fileToStore);
-                if (freshRecord) {
-                    this.#memoryCache.set(uri, freshRecord);
-                }
-                if (!!(await this.#putFile(fileToStore, uri))) {
-                    storedFile = await this.#getFile(uri);
-                } else {
-                    storedFile = freshRecord ?? fileToStore;
-                }
+            if (fileToStore && !!(await this.#putFile(fileToStore, uri))) {
+                storedFile = await this.#getFile(uri);
+            } else {
+                storedFile = fileToStore;
             }
         }
         return storedFile;
@@ -921,6 +801,5 @@ export default class FileStorage {
             } catch {}
         }
         this.#db = undefined;
-        this.#memoryCache.clear();
     }
 }

package/src/gltf-resolver.js

@@ -82,27 +82,27 @@ export default class GLTFResolver {
      *   - If parsing fails, returns a Blob with MIME type "model/gltf-binary" and extension ".glb".
      *   - If decoding fails, returns nulls for blob and extension.
      */
-    async #decodeBase64(base64) {
+    #decodeBase64(base64) {
         const [, payload] = base64.split(",");
         const raw = payload || base64;
-        const size = raw.length;
-
-        // Detect format from first base64 chars — O(1), no full decode needed.
-        // GLB magic bytes 0x676c5446 ("glTF") encode to "Z2x" in base64.
-        // GLTF JSON always starts with '{' (0x7B), which encodes to "ey" in base64.
-        const isGlb = raw.startsWith("Z2x");
-        const extension = isGlb ? ".glb" : ".gltf";
-        const type = isGlb ? "model/gltf-binary" : "model/gltf+json";
-
+        let decoded = "";
         let blob = null;
+        let extension = null;
+        let size = raw.length;
         try {
-            // Native browser decode: runs in C++ off the JS call stack, does not block the
-            // main thread. Avoids the per-character Uint8Array loop and the full JSON.parse
-            // that the previous sync implementation used to detect the file type.
-            blob = await fetch(`data:${type};base64,${raw}`).then((r) => r.blob());
+            decoded = atob(raw);
         } catch {
-            return { blob: null, extension: null, size };
+            return { blob, extension, size };
         }
+        let isJson = false;
+        try {
+            JSON.parse(decoded);
+            isJson = true;
+        } catch {}
+        extension = isJson ? ".gltf" : ".glb";
+        const type = isJson ? "model/gltf+json" : "model/gltf-binary";
+        const array = Uint8Array.from(decoded, (c) => c.charCodeAt(0));
+        blob = new Blob([array], { type });
         return { blob, extension, size };
     }
 
@@ -138,27 +138,6 @@ export default class GLTFResolver {
         return typeof url === "string" && url.startsWith("blob:");
     }
 
-    /**
-     * Check whether a source should be treated as embedded base64/data URI.
-     * @private
-     * @param {string} source - Value to test.
-     * @returns {boolean} True when the source is a data URI or raw base64 payload.
-     */
-    #isEmbeddedBase64Source(source) {
-        if (typeof source !== "string") {
-            return false;
-        }
-        const normalized = source.trim();
-        if (!normalized) {
-            return false;
-        }
-        if (normalized.startsWith("data:")) {
-            return true;
-        }
-        // Raw base64 payloads use the standard alphabet and have no URL separators.
-        return /^[A-Za-z0-9+/=_-]+$/.test(normalized);
-    }
-
     /**
      * Collects asset entries that have an external URI (non-data URI) and stores a normalized absolute or relative-resolved URI for later replacement.
      * @private
@@ -225,19 +204,17 @@ export default class GLTFResolver {
             assetContainerJSON.images.forEach((asset, index, array) => this.#saveAssetData(asset, index, array, sceneURLBase, arrayOfAssetsWithURI));
         }
 
-        // Batch-resolve all asset URIs in a single IDB transaction to avoid per-URI transaction
-        // overhead. Falls back to individual getURL() for URIs not found in IDB.
-        const urisToResolve = arrayOfAssetsWithURI.map((asset) => asset.uri);
-        const urlMap = await this.#fileStorage.getURLBatch(urisToResolve);
-        arrayOfAssetsWithURI.forEach((asset) => {
-            const resolvedUrl = urlMap.get(asset.uri);
-            if (resolvedUrl) {
-                asset.parent[asset.index].uri = resolvedUrl;
-                if (this.#isBlobURL(resolvedUrl)) {
-                    objectURLs.push(resolvedUrl);
+        // Replace parallel URIs so that if files are not stored yet, they are downloaded in parallel
+        const promisesArray = arrayOfAssetsWithURI.map(async (asset) => {
+            const uri = await this.#fileStorage.getURL(asset.uri);
+            if (uri) {
+                asset.parent[asset.index].uri = uri;
+                if (this.#isBlobURL(uri)) {
+                    objectURLs.push(uri);
                 }
             }
         });
+        await Promise.all(promisesArray);
     }
 
     /**
@@ -293,9 +270,7 @@ export default class GLTFResolver {
 
         if (storage.db && storage.table && storage.id) {
             await this.#initializeStorage(storage.db, storage.table);
-            const tIdb = performance.now();
             const object = await loadModel(storage.id, storage.table);
-            console.log(`[perf][gltf:${storage.id}] IDB read ${Math.round(performance.now() - tIdb)}ms`);
             if (!object || !object.data || !object.timeStamp || !object.size) {
                 return false;
             }
@@ -315,21 +290,12 @@ export default class GLTFResolver {
         }
 
         let file = null;
-        let blob = null;
-        let extension = null;
-        let size = 0;
-        if (this.#isEmbeddedBase64Source(source)) {
-            const tDecode = performance.now();
-            ({ blob, extension, size } = await this.#decodeBase64(source));
-            console.log(`[perf][gltf:${storage.id ?? "url"}] decode(${extension}) ${Math.round(performance.now() - tDecode)}ms`);
-        }
+        let { blob, extension, size } = this.#decodeBase64(source);
 
         if (blob && extension) {
             if (extension === ".gltf") {
                 const assetContainerJSON = JSON.parse(await blob.text());
-                const tReplace = performance.now();
                 await this.#replaceSceneURIAsync(assetContainerJSON, source, objectURLs);
-                console.log(`[perf][gltf:${storage.id ?? "url"}] replaceURIs ${Math.round(performance.now() - tReplace)}ms (${objectURLs.length} assets)`);
                 source = `data:${JSON.stringify(assetContainerJSON)}`;
             } else {
                 file = new File([blob], `file${extension}`, {

package/src/pref-viewer-3d.js

@@ -62,7 +62,6 @@ import FileStorage from "./file-storage.js";
  * Events:
  *  - "scene-loading": Dispatched when a loading operation starts.
  *  - "scene-loaded": Dispatched when a loading operation completes.
- *  - "model-first-painted": Dispatched when the model-only preview has actually painted a frame.
  *  - "scene-setting-options": Dispatched when viewer options are being set.
  *  - "scene-set-options": Dispatched when viewer options have been set.
  *
@@ -77,7 +76,6 @@ export default class PrefViewer3D extends HTMLElement {
     #isLoaded = false;
     #isVisible = false;
     #lastLoadTimestamp = undefined;
-    #suppressVisibilityAttributeCallback = false;
 
     #wrapper = null;
     #canvas = null;
@@ -114,9 +112,6 @@ export default class PrefViewer3D extends HTMLElement {
      * - "visible": shows or hides the component according to the attribute value ("true"/"false").
      */
     attributeChangedCallback(name, _old, value) {
-        if (this.#suppressVisibilityAttributeCallback && (name === "show-model" || name === "show-scene")) {
-            return;
-        }
         switch (name) {
             case "show-model":
                 if (_old === value) {
@@ -721,62 +716,6 @@ export default class PrefViewer3D extends HTMLElement {
         return { success: someSetted, detail: detail };
     }
 
-    /**
-     * Loads the model container independently in the background while the render loop keeps running.
-     * Merges the model into the scene atomically when ready, without stopping camera-dependent effects.
-     * @public
-     * @param {object} payload - Model payload with storage pointer and optional timestamp.
-     * @returns {Promise<{success: boolean, error: any, loadedContainers: string[]}>}
-     */
-    async loadModelIndependent(payload) {
-        if (!this.#babylonJSController) {
-            return { success: false, error: "Controller not initialized", loadedContainers: [] };
-        }
-        // #checkNeedToUpdateContainers passed as callback — called AFTER any in-progress #loadContainers
-        // finishes so the scene load doesn't also pick up and consume the model container.
-        return await this.#babylonJSController.loadContainerIndependent("model", () => {
-            this.#checkNeedToUpdateContainers({ model: payload });
-        }, { loadSessionId: payload?.loadSessionId ?? null });
-    }
-
-    /**
-     * Loads the environment/scene container independently in the background, in parallel with any
-     * ongoing model load. Applies IBL (HDR) if the scene payload includes an ibl property.
-     * Dispatches "scene-loading" and "scene-loaded" (or "scene-error") events directly.
-     * @public
-     * @param {object|string} scene - Scene payload: { storage, ibl?, visible? }
-     * @returns {Promise<{success: boolean, error: any, loadedContainers: string[]}>}
-     */
-    async loadSceneIndependent(scene) {
-        if (!this.#babylonJSController) {
-            return { success: false, error: "Controller not initialized", loadedContainers: [] };
-        }
-        // Pre-mark IBL as pending before entering loadContainerIndependent — the onReady callback
-        // is synchronous so async IBL resolution must happen here, not inside it.
-        if (scene?.ibl !== undefined) {
-            await this.#checkNeedToUpdateIBL({ ibl: scene.ibl });
-        }
-        return await this.#babylonJSController.loadContainerIndependent("environment", () => {
-            this.#checkNeedToUpdateContainers({ scene });
-        });
-    }
-
-    /**
-     * Loads the materials container independently in the background, in parallel with any
-     * ongoing model or environment load.
-     * @public
-     * @param {object|string} materials - Materials payload: { storage }
-     * @returns {Promise<{success: boolean, error: any, loadedContainers: string[]}>}
-     */
-    async loadMaterialsIndependent(materials) {
-        if (!this.#babylonJSController) {
-            return { success: false, error: "Controller not initialized", loadedContainers: [] };
-        }
-        return await this.#babylonJSController.loadContainerIndependent("materials", () => {
-            this.#checkNeedToUpdateContainers({ materials });
-        });
-    }
-
     /**
      * Shows the 3D model within the viewer.
      * @public
@@ -825,31 +764,6 @@ export default class PrefViewer3D extends HTMLElement {
         this.#babylonJSController.setContainerVisibility("environment", false);
     }
 
-    /**
-     * Reflects the current visibility of a container without re-triggering the command queue.
-     * Used by BabylonJSController when the visibility change originated from the renderer itself.
-     * @public
-     * @param {string} name - Container name ("model" or "environment").
-     * @param {boolean} isVisible - Whether the container should be reflected as visible.
-     * @returns {void}
-     */
-    syncVisibility(name, isVisible) {
-        const attrName = name === "model" ? "show-model" : name === "environment" ? "show-scene" : null;
-        if (!attrName) {
-            return;
-        }
-        const nextValue = isVisible ? "true" : "false";
-        if (this.getAttribute(attrName) === nextValue) {
-            return;
-        }
-        this.#suppressVisibilityAttributeCallback = true;
-        try {
-            this.setAttribute(attrName, nextValue);
-        } finally {
-            this.#suppressVisibilityAttributeCallback = false;
-        }
-    }
-
     /**
      * Downloads the current 3D model as a GLB file.
      * @public
@@ -1101,22 +1015,4 @@ export default class PrefViewer3D extends HTMLElement {
     get isVisible() {
         return this.#isVisible;
     }
-
-    /**
-     * Forces the active camera to frame the visible model.
-     * @public
-     * @returns {boolean}
-     */
-    focusModel() {
-        return this.#babylonJSController?.focusModel?.() ?? false;
-    }
-
-    /**
-     * Returns a debug snapshot of the internal 3D state, including camera data.
-     * @public
-     * @returns {object|null}
-     */
-    getDebugState() {
-        return this.#babylonJSController?.getDebugState?.() ?? null;
-    }
 }

package/src/pref-viewer.js

@@ -66,7 +66,6 @@ export default class PrefViewer extends HTMLElement {
     #cultureList = SUPPORTED_LOCALES;
     #culture = "";
     #cultureSuppressAttribute = false;
-    #suppressVisibilityAttributeCallback = false;
 
     // References to internal components
     #wrapper = null;
@@ -121,9 +120,6 @@ export default class PrefViewer extends HTMLElement {
      * @returns {void}
      */
     attributeChangedCallback(name, _old, value) {
-        if (this.#suppressVisibilityAttributeCallback && (name === "show-model" || name === "show-scene")) {
-            return;
-        }
         switch (name) {
             case "config":
                 this.loadConfig(value);
@@ -631,47 +627,20 @@ export default class PrefViewer extends HTMLElement {
     /**
      * Handles the completion of a 3D loading operation.
      * Updates loading state, sets attributes, dispatches a "scene-loaded" event, and processes the next task.
-     * Dispatches granular container events ("model-loaded", "environment-loaded", "materials-loaded")
-     * for each successfully loaded container before firing "scene-loaded".
-     * The independent model path may additionally emit "model-first-painted" when the first painted
-     * frame is acknowledged by the Babylon controller.
      * @private
      * @param {object} [detail] - Optional details to include in the event.
-     * @param {string[]} [detail.loadedContainers] - Names of containers that loaded successfully.
      * @returns {void}
      */
     #on3DLoaded(detail) {
         this.#isLoaded = true;
         this.#isLoading = false;
-
+        
         this.#menu3DSyncSettings();
         this.#menu3DUpdateSwitchAvailability();
 
         this.removeAttribute("loading-3d");
         this.setAttribute("loaded-3d", "");
 
-        // Dispatch granular container events before the aggregate "scene-loaded".
-        // This lets consumers react as soon as individual assets are ready without
-        // waiting for the full scene-loaded signal.
-        const granularEventMap = {
-            model: "model-loaded",
-            environment: "environment-loaded",
-            materials: "materials-loaded",
-        };
-        if (Array.isArray(detail?.loadedContainers)) {
-            const granularEventOptions = {
-                bubbles: true,
-                cancelable: false,
-                composed: true,
-            };
-            detail.loadedContainers.forEach((containerName) => {
-                const eventName = granularEventMap[containerName];
-                if (eventName) {
-                    this.dispatchEvent(new CustomEvent(eventName, granularEventOptions));
-                }
-            });
-        }
-
         const customEventOptions = {
             bubbles: true,
             cancelable: true,
@@ -1152,78 +1121,6 @@ export default class PrefViewer extends HTMLElement {
         this.#addTaskToQueue(model, "model");
     }
 
-    /**
-     * Loads the model container in parallel with any ongoing scene load, bypassing the task queue.
-     * Dispatches "model-loading", "model-first-painted", and "model-loaded" events directly.
-     * @public
-     * @param {object|string} model - Model payload with storage pointer.
-     * @returns {Promise<void>}
-     */
-    async loadModelParallel(model) {
-        model = typeof model === "string" ? JSON.parse(model) : model;
-        if (!model || !this.#component3D) return;
-        const eventOptions = { bubbles: true, cancelable: false, composed: true };
-        this.dispatchEvent(new CustomEvent("model-loading", eventOptions));
-        try {
-            const detail = await this.#component3D.loadModelIndependent(model);
-            if (detail?.success) {
-                this.dispatchEvent(new CustomEvent("model-loaded", { ...eventOptions, detail }));
-            } else {
-                this.dispatchEvent(new CustomEvent("model-error", { ...eventOptions, detail }));
-            }
-        } catch (error) {
-            this.dispatchEvent(new CustomEvent("model-error", { ...eventOptions, detail: { error } }));
-        }
-    }
-
-    /**
-     * Loads the environment/scene container in parallel with any ongoing model load, bypassing the
-     * task queue. Dispatches "scene-loading" and "scene-loaded" (or "scene-error") events directly.
-     * @public
-     * @param {object|string} scene - Scene payload: { storage, ibl?, visible? }
-     * @returns {Promise<void>}
-     */
-    async loadSceneParallel(scene) {
-        scene = typeof scene === "string" ? JSON.parse(scene) : scene;
-        if (!scene || !this.#component3D) return;
-        const eventOptions = { bubbles: true, cancelable: false, composed: true };
-        this.dispatchEvent(new CustomEvent("scene-loading", eventOptions));
-        try {
-            const detail = await this.#component3D.loadSceneIndependent(scene);
-            if (detail?.success) {
-                this.dispatchEvent(new CustomEvent("scene-loaded", { ...eventOptions, detail }));
-            } else {
-                this.dispatchEvent(new CustomEvent("scene-error", { ...eventOptions, detail }));
-            }
-        } catch (error) {
-            this.dispatchEvent(new CustomEvent("scene-error", { ...eventOptions, detail: { error } }));
-        }
-    }
-
-    /**
-     * Loads the materials container in parallel with any ongoing model or environment load,
-     * bypassing the task queue. Dispatches "materials-loading" and "materials-loaded" events.
-     * @public
-     * @param {object|string} materials - Materials payload: { storage }
-     * @returns {Promise<void>}
-     */
-    async loadMaterialsParallel(materials) {
-        materials = typeof materials === "string" ? JSON.parse(materials) : materials;
-        if (!materials || !this.#component3D) return;
-        const eventOptions = { bubbles: true, cancelable: false, composed: true };
-        this.dispatchEvent(new CustomEvent("materials-loading", eventOptions));
-        try {
-            const detail = await this.#component3D.loadMaterialsIndependent(materials);
-            if (detail?.success) {
-                this.dispatchEvent(new CustomEvent("materials-loaded", { ...eventOptions, detail }));
-            } else {
-                this.dispatchEvent(new CustomEvent("materials-error", { ...eventOptions, detail }));
-            }
-        } catch (error) {
-            this.dispatchEvent(new CustomEvent("materials-error", { ...eventOptions, detail: { error } }));
-        }
-    }
-
     /**
      * Loads a scene/environment object or JSON string and adds it to the task queue.
      * @public
@@ -1368,31 +1265,6 @@ export default class PrefViewer extends HTMLElement {
         this.#addTaskToQueue(config, "visibility");
     }
 
-    /**
-     * Reflects the current visibility of a container without feeding the task queue.
-     * Used by the Babylon controller to keep host attributes in sync with renderer state.
-     * @public
-     * @param {string} name - Container name ("model" or "environment").
-     * @param {boolean} isVisible - Whether the container should be reflected as visible.
-     * @returns {void}
-     */
-    syncVisibility(name, isVisible) {
-        const attrName = name === "model" ? "show-model" : name === "environment" ? "show-scene" : null;
-        if (!attrName) {
-            return;
-        }
-        const nextValue = isVisible ? "true" : "false";
-        if (this.getAttribute(attrName) === nextValue) {
-            return;
-        }
-        this.#suppressVisibilityAttributeCallback = true;
-        try {
-            this.setAttribute(attrName, nextValue);
-        } finally {
-            this.#suppressVisibilityAttributeCallback = false;
-        }
-    }
-
     /**
      * Centers the 2D drawing view in the viewer.
      * @public
@@ -1647,22 +1519,4 @@ export default class PrefViewer extends HTMLElement {
     get isMode3D() {
         return this.#mode === "3d";
     }
-
-    /**
-     * Forces the 3D camera to frame the current model, when supported.
-     * @public
-     * @returns {boolean}
-     */
-    focusModel() {
-        return this.#component3D?.focusModel?.() ?? false;
-    }
-
-    /**
-     * Exposes a debug snapshot of the 3D runtime when available.
-     * @public
-     * @returns {object|null}
-     */
-    getDebugState() {
-        return this.#component3D?.getDebugState?.() ?? null;
-    }
 }

package/src/styles.js

@@ -106,7 +106,6 @@ export const PrefViewer3DStyles = `
         position: relative;
         outline: none;
         box-sizing: border-box;
-        background: #ffffff;
     }
 `;