@x-viewer/core 0.21.13 → 0.21.15

package/dist/types/core/dxf-parser/DxfParser.d.ts

@@ -1,118 +1,5 @@
-import type { DwgDatabase } from "@mlightcad/libredwg-web";
-import IGeometry, { IEntity, IPoint } from "./entities/geomtry";
-import { IClass, IObjectParser } from "./objects/common";
-import { IDictionaryObject } from "./objects/dictionary";
-import { IImageDefObject } from "./objects/imagedef";
-import { ILayoutObject } from "./objects/layout";
-import { ISortEntsTableObject } from "./objects/sortentstable";
-import { ISpatialFilterObject } from "./objects/spatialfilter";
-import { IXRecord } from "./objects/xrecord";
-/**
- * Definition of a block. Which contains entities, name, handle, etc.
- * @hidden
- */
-export interface IBlock {
-    entities: IEntity[];
-    ownerHandle: string;
-    xrefPath: string;
-    name: string;
-    name2: string;
-    handle: string;
-    layer: string;
-    position: IPoint;
-    paperSpace: boolean;
-    blockType: BlockTypeFlags;
-    description?: string;
-}
-/**
- * Definition of a viewport.
- * @hidden
- */
-export interface IViewport {
-    name: string;
-    handle?: string;
-    lowerLeftCorner: IPoint;
-    upperRightCorner: IPoint;
-    center: IPoint;
-    snapBasePoint: IPoint;
-    snapSpacing: IPoint;
-    gridSpacing: IPoint;
-    viewDirectionFromTarget: IPoint;
-    viewTarget: IPoint;
-    aspectRatio: number;
-    lensLength: number;
-    frontClippingPlane: string | number | boolean;
-    backClippingPlane: string | number | boolean;
-    viewHeight: number;
-    snapRotationAngle: number;
-    viewTwistAngle: number;
-    orthographicType: number;
-    ucsOrigin: IPoint;
-    ucsXAxis: IPoint;
-    ucsYAxis: IPoint;
-    renderMode: string;
-    defaultLightingType: number;
-    defaultLightingOn: boolean;
-    ownerHandle: string;
-    ambientColor: number;
-}
-/**
- * Viewport table definition.
- * @hidden
- */
-export interface IViewportTableDefinition {
-    dxfSymbolName: "VPORT";
-    parseTableRecords(): IViewport[];
-}
-/**
- * Reference to DwgLineTypeElement
- */
-export interface LineTypeElement {
-    elementLength: number;
-    /**
-     * 0: Dash
-     * 1: Element is a shape (a vector glyph from a compiled .SHX file)
-     * 2: Element is a text string
-     * 3: Reserved
-     */
-    elementTypeFlag: number;
-    /**
-     * Index of the shape inside the .SHX file defined by styleObjectId.
-     * It should be useful when elementTypeFlag is 1.
-     */
-    shapeNumber?: number;
-    styleObjectId?: string;
-    scale?: number;
-    rotation?: number;
-    offsetX?: number;
-    offsetY?: number;
-    text?: string;
-}
-/**
- * Line type.
- * @hidden
- */
-export interface ILineType {
-    /**
-     * AutoCAD entity handle as hex string
-     */
-    handle?: string;
-    name: string;
-    description: string;
-    pattern: LineTypeElement[];
-    /**
-     * The sum length of each pattern segment.
-     */
-    patternLength: number;
-}
-/**
- * Line type table definition.
- * @hidden
- */
-export interface ILineTypeTableDefinition {
-    dxfSymbolName: "LTYPE";
-    parseTableRecords(): Record<string, ILineType>;
-}
+import IGeometry from "./entities/geomtry";
+import { IObjectParser } from "./objects/common";
 /**
  * Definition of a layer.
  */
@@ -152,301 +39,6 @@ export interface ILayer {
      */
     lineweight: 0 | 5 | 9 | 13 | 15 | 18 | 20 | 25 | 30 | 35 | 40 | 50 | 53 | 60 | 70 | 80 | 90 | 100 | 106 | 120 | 140 | 158 | 200 | 211 | -3 | -2 | -1;
 }
-/**
- * Layer table definition.
- * @hidden
- */
-export interface ILayerTableDefinition {
-    dxfSymbolName: "LAYER";
-    parseTableRecords(): Record<string, ILayer>;
-}
-/**
- * BlockRecord
- * @hidden
- */
-export interface IBlockRecord {
-    handle: string;
-    ownerHandle: string;
-    blockName: string;
-    layoutHandle: string;
-    blockInsertUnits: number;
-    blockExplodability: number;
-    blockScalability: number;
-    bitmap?: string;
-}
-/**
- * @hidden
- */
-export interface IBlockRecordTableDefinition {
-    dxfSymbolName: "BLOCK_RECORD";
-    parseTableRecords(): Record<string, IBlockRecord>;
-}
-/**
- * Definition of a style.
- * @hidden
- */
-export interface IStyle {
-    handle: string;
-    ownerHandle: string;
-    styleName: string;
-    priorTextHeight: number;
-    textHeight: number;
-    xScale: number;
-    rotation: number;
-    mirrorType: number;
-    fontFile: string;
-    bigFontFile: string;
-}
-/**
- * Style table definition.
- * @hidden
- */
-export interface IStyleTableDefinition {
-    dxfSymbolName: "STYLE";
-    parseTableRecords(): Record<string, IStyle>;
-}
-/**
- * Dim style.
- * @hidden
- */
-export interface IDimStyle {
-    /**
-     * AutoCAD entity handle as hex string
-     */
-    handle?: string;
-    styleName: string;
-    DIMSCALE: number;
-    DIMASZ: number;
-    DIMEXO: string;
-    DIMEXE: string;
-    DIMSE1: string;
-    DIMSE2: string;
-    DIMTAD: string;
-    DIMTXT: string;
-    DIMGAP: number;
-    DIMCLRD: number;
-    DIMCLRT: number;
-    DIMLFAC: number;
-    DIMDEC: string;
-    DIMLDRBLK: string;
-}
-/**
- * Dim style table definition
- * @hidden
- */
-export interface IDimStyleTableDefinition {
-    dxfSymbolName: "DIMSTYLE";
-    parseTableRecords(): Record<string, IDimStyle>;
-}
-/**
- * Table definitions.
- * @hidden
- */
-export interface ITableDefinitions {
-    VPORT: IViewportTableDefinition;
-    LTYPE: ILineTypeTableDefinition;
-    LAYER: ILayerTableDefinition;
-    BLOCK_RECORD: IBlockRecordTableDefinition;
-    STYLE: IStyleTableDefinition;
-    DIMSTYLE: IDimStyleTableDefinition;
-}
-/**
- * Base table
- * @hidden
- */
-export interface IBaseTable {
-    handle: string;
-    ownerHandle: string;
-}
-/**
- * Viewport table
- * @hidden
- */
-export interface IViewportTable extends IBaseTable {
-    entries: IViewport[];
-}
-/**
- * @hidden
- */
-export interface ILayerTypesTable extends IBaseTable {
-    entries: Record<string, ILineType>;
-}
-/**
- * @hidden
- */
-export interface ILayersTable extends IBaseTable {
-    entries: Record<string, ILayer>;
-}
-/**
- * @hidden
- */
-export interface IStylesTable extends IBaseTable {
-    entries: Record<string, IStyle>;
-}
-/**
- * @hidden
- */
-export interface IDimStyleTable extends IBaseTable {
-    entries: Record<string, IDimStyle>;
-}
-/**
- * Block records table containing metadata for all blocks defined in the DXF file.
- * Each block record provides information about a block, including:
- * - Block name and handle
- * - Associated layout handle (for model space and paper space blocks)
- * - Block insertion units, explodability, and scalability
- * - Preview bitmap (if available)
- *
- * Block records are used to link blocks with their corresponding layouts and provide
- * additional metadata beyond what is stored in the blocks themselves.
- *
- * @hidden
- */
-export interface IBlockRecordsTable extends IBaseTable {
-    /**
-     * Block record entries, keyed by block record handle (hex string).
-     * Each entry corresponds to a block definition in the DXF file.
-     */
-    entries: Record<string, IBlockRecord>;
-}
-/**
- * Collection of all DXF tables.
- * DXF tables are used to define named resources that can be referenced by entities.
- * Each table contains entries that define reusable objects with specific properties.
- * @hidden
- */
-export interface ITables {
-    /**
-     * Viewport table containing viewport configurations.
-     * Viewports define how the drawing is displayed, including view direction,
-     * zoom level, and clipping planes.
-     */
-    VPORT: IViewportTable;
-    /**
-     * Linetype table containing line pattern definitions.
-     * Linetypes define how lines are drawn (solid, dashed, dotted, etc.).
-     * Common linetypes include "CONTINUOUS", "DASHED", "DOTTED", and custom patterns.
-     */
-    LTYPE: ILayerTypesTable;
-    /**
-     * Layer table containing layer definitions.
-     * Layers organize entities and control their visibility, color, linetype, and other properties.
-     * Every entity in a DXF file belongs to a layer.
-     */
-    LAYER: ILayersTable;
-    /**
-     * Block records table containing block metadata.
-     * Block records provide information about blocks and link them to layouts.
-     * This table is essential for understanding the relationship between blocks and layouts.
-     */
-    BLOCK_RECORD: IBlockRecordsTable;
-    /**
-     * Text style table containing font and text formatting definitions.
-     * Text styles define how text entities are displayed, including font file,
-     * height, width factor, and rotation.
-     */
-    STYLE: IStylesTable;
-    /**
-     * Dimension style table containing dimension formatting definitions.
-     * Dimension styles control how dimensions are displayed, including arrow types,
-     * text placement, precision, and colors.
-     */
-    DIMSTYLE: IDimStyleTable;
-}
-/**
- * Collection of all DXF objects.
- * Provides typed access to common object arrays so callers don't need to use string keys like "LAYOUT" or "DICTIONARY".
- * @hidden
- */
-export interface IObjects {
-    LAYOUT?: ILayoutObject[];
-    DICTIONARY?: IDictionaryObject[];
-    IMAGEDEF?: IImageDefObject[];
-    SORTENTSTABLE?: ISortEntsTableObject[];
-    SPATIAL_FILTER?: ISpatialFilterObject[];
-    XRECORD?: IXRecord[];
-}
-/**
- * Union type representing any DXF table.
- * This type can be used when a function or method needs to accept any table type
- * without being specific about which table it is.
- *
- * @hidden
- */
-export type ITable = IViewportTable | ILayerTypesTable | ILayersTable | IBlockRecordsTable | IStylesTable | IDimStyleTable;
-/**
- * Represents the complete structure of a DXF (Drawing Exchange Format) file.
- * A DXF file is organized into several sections: HEADER, ENTITIES, BLOCKS, TABLES, OBJECTS, and CLASSES.
- *
- * @hidden
- */
-export interface IDxf {
-    /**
-     * Header section containing system variables.
-     * These variables control various drawing settings such as:
-     * - `$ACADVER`: AutoCAD version (e.g., "AC1032" for AutoCAD 2018)
-     * - `$CLAYER`: Current layer name
-     * - `$LTSCALE`: Global linetype scale
-     * - `$INSUNITS`: Units for insertion
-     * - And many other system variables
-     * Values can be points (IPoint), numbers, or strings.
-     */
-    header: Record<string, IPoint | number | string>;
-    /**
-     * Entities section containing all drawing entities.
-     * This includes geometric objects such as:
-     * - Lines, arcs, circles, ellipses
-     * - Polylines, splines, hatches
-     * - Text, dimensions, leaders
-     * - Blocks (inserts), images, viewports
-     * - And other entity types
-     * Note that, it should include entities in model space and paper space.
-     * But it should not include entities in blocks.
-     */
-    entities: IEntity[];
-    /**
-     * Blocks section containing block definitions.
-     * The key is the block name (e.g., "*Model_Space", "*Paper_Space", or user-defined block names).
-     * Each block contains a collection of entities that can be inserted multiple times via INSERT entities.
-     * Blocks can represent:
-     * - Model space and paper space definitions
-     * - User-defined reusable components
-     * - Dimension blocks
-     */
-    blocks: Record<string, IBlock>;
-    /**
-     * Tables section containing various DXF tables.
-     * Includes:
-     * - `VPORT`: Viewport table (view configurations)
-     * - `LTYPE`: Linetype table (line pattern definitions)
-     * - `LAYER`: Layer table (layer definitions with properties)
-     * - `BLOCK_RECORD`: Block record table (block metadata)
-     * - `STYLE`: Text style table (font and text formatting)
-     * - `DIMSTYLE`: Dimension style table (dimension formatting)
-     */
-    tables: ITables;
-    /**
-     * Objects section containing non-graphical objects.
-     * The key is the object type name (e.g., "LAYOUT", "DICTIONARY", "XRECORD").
-     * Common object types include:
-     * - `LAYOUT`: Layout definitions (Model space and paper space layouts)
-     * - `DICTIONARY`: Named object dictionaries
-     * - `XRECORD`: Extended record objects
-     * - `MATERIAL`: Material definitions
-     * - And other application-specific objects
-     */
-    objects: IObjects;
-    /**
-     * Classes section containing application-defined class definitions.
-     * Classes define custom entity types or objects that may be used by specific applications.
-     * Each class entry describes:
-     * - Application name
-     * - Class name and C++ class name
-     * - DXF name
-     * - Capabilities and proxy information
-     */
-    classes: IClass[];
-}
 export default class DxfParser {
     constructor(encoding?: string);
     parse(source: string | ArrayBuffer): IDxf | undefined;
@@ -457,17 +49,4 @@ export default class DxfParser {
     parseAsync(source: string | ArrayBuffer): Promise<IDxf | undefined>;
     registerEntityHandler(handlerType: new () => IGeometry): void;
     registerObjectHandler(handlerType: new () => IObjectParser): void;
-    /**
-     * Loads libredwg if needed, then returns raw convertEx() output plus version/codepage.
-     * Used by dwg_json_viewer and debugging tools.
-     */
-    libredwgConvertExAsync(data: ArrayBuffer): Promise<{
-        version: string;
-        codepage: string;
-        database: DwgDatabase;
-        stats: {
-            unknownEntityCount: number;
-        };
-    } | undefined>;
-    private parseDwgDb;
 }

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

@@ -58,6 +58,32 @@ export declare class EffectManager {
     get unrealBloomPassEnabled(): boolean;
     set unrealBloomPassEnabled(enable: boolean);
     setOutlinePassSelectObjects(objects: THREE.Object3D[]): void;
+    /**
+     * Sets current selection outline objects.
+     * When objects is empty, the pass is disabled.
+     *
+     * Intended for 3D viewer selection highlighting; 2D callers should avoid using this.
+     */
+    setSelectionOutline(objects: THREE.Object3D[]): void;
+    /**
+     * OutlinePass is screen-space (depth/normal): not every geometric edge appears.
+     * Colors are sRGB display values (no HDR boost): outline runs after {@link OutputPass}, so it is not
+     * washed out by tone mapping.
+     */
+    private applySelectionOutlineAppearance;
+    /**
+     * The stock {@link OutlinePass} overlay material uses `AdditiveBlending`.
+     * Additive blend on a white background: `clamp(1 + x) = 1` — the outline is **mathematically invisible**.
+     *
+     * Replace the overlay with `NormalBlending` + a shader that outputs proper alpha so the edge color
+     * **covers** the background instead of being added to it. This works on any background brightness.
+     */
+    private patchOutlineOverlayBlending;
+    /**
+     * Internal buffers must use the same pixel dimensions as {@link EffectComposer} (logical size × DPR);
+     * otherwise on HiDPI screens edges are detected on an undersized grid and look ~1px thin and dim.
+     */
+    private outlinePassResolution;
     enableModelEdges(enable: boolean): void;
     showVertexNormals(show: boolean, size?: number): void;
     setSize(width: number, height: number): void;
@@ -74,8 +100,8 @@ export declare class EffectManager {
     private syncWatermarkResolution;
     private ensureComposerOutputPass;
     /**
-     * Keep {@link composerOutputPass} last (screen output), and the GLSL watermark pass immediately before it
-     * so it composites in linear space; OutputPass applies renderer tone mapping and output color space to the canvas.
+     * Order: …other passes… → watermark (linear) → {@link composerOutputPass} (tone map + output encoding)
+     * → {@link outlinePass} when present (selection outline avoids tone mapping by compositing last).
      */
     private ensurePostprocessPassOrder;
 }

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

@@ -6,6 +6,11 @@ interface BaseModelLoadContext {
     /** Normalized lowercase format token; same semantics as historical `endsWith` checks. */
     readonly format: string;
     readonly onProgress?: (event: ProgressEvent) => void;
+    /**
+     * Per-load mesh quantization (see {@link ModelConfig.quantize}). When `false` or omitted on
+     * {@link ModelConfig}, loaders skip quantization; {@link Viewer3d} fills omission from {@link BaseViewer.enableQuantization}.
+     */
+    readonly quantize?: boolean;
 }
 /**
  * Context for model loading from URL.
@@ -43,7 +48,18 @@ export declare abstract class BaseModelLoader {
      * Override for non-suffix matching.
      */
     match(format: string): boolean;
+    /**
+     * When {@link ModelLoadContext.quantize} is strictly `true`, quantizes mesh
+     * {@link THREE.BufferGeometry} under `scene` (see {@link GeometryUtils.applyMeshQuantizationToSceneRoot}).
+     */
+    protected maybeQuantizeLoadedScene(scene: THREE.Object3D, quantize?: boolean): THREE.Object3D;
     load?(ctx: ModelLoadContext): Promise<THREE.Object3D | void>;
     loadFromBuffer?(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D | void>;
+    /**
+     * Called by ModelLoaderManager when the active LoadingManager changes
+     * (e.g. for multi-file local loads with a URL modifier).
+     * Implementations should reset any cached internal loader instances.
+     */
+    updateManager?(manager: THREE.LoadingManager | undefined): void;
 }
 export {};

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

@@ -5,17 +5,18 @@ import { BaseModelLoader } from "./BaseModelLoader";
  * glTF / GLB model loader wrapping GLTFLoader, DRACO path, and progress handling.
  */
 export declare class GltfLoader extends BaseModelLoader {
-    private readonly manager?;
     readonly id = "loader.builtin.gltf";
     readonly priority = 0;
     readonly formats: readonly ["gltf", "glb"];
     private static dracoDecoderPath;
     static setDracoDecoderPath(path: string): void;
     private gltfLoader?;
-    constructor(manager?: THREE.LoadingManager | undefined);
+    private manager?;
+    constructor(manager?: THREE.LoadingManager);
+    updateManager(manager: THREE.LoadingManager | undefined): void;
     load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
     loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
-    parseToScene(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    parseToScene(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void, quantize?: boolean): void;
     private obtainLoader;
     private applyRequestHeader;
     private sanitizeUrlForLoad;

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

@@ -1,5 +1,6 @@
 import * as THREE from "three";
 import type { BaseModelLoader } from "./BaseModelLoader";
+import type { ModelConfig } from "../../core/Configs";
 import type { FontManager } from "../../core/font";
 export declare class ModelLoaderManager {
     private manager?;
@@ -25,14 +26,20 @@ export declare class ModelLoaderManager {
      */
     getLoaderById(id: string): BaseModelLoader | undefined;
     private computeUrlModelFormat;
+    /**
+     * @param modelCfg Load-related fields from {@link ModelConfig} (`src` is the logical file name for
+     *        format detection when `blobFetchUrl` is set).
+     * @param blobFetchUrl When set (e.g. `blob:` URL), requests use this URL while format is inferred from `modelCfg.src`.
+     */
     private loadModelInternal;
     private loadModelFromBufferInternal;
     setLoadManager(manager?: THREE.LoadingManager): void;
-    loadLocalModel(url: string, src: string, onProgress?: (event: ProgressEvent) => void, mtlUrls?: string[]): Promise<THREE.Object3D>;
-    loadModel(src: string, fileFormat?: string, onProgress?: (event: ProgressEvent) => void, requestHeader?: {
-        [header: string]: string;
-    }): Promise<THREE.Object3D | void>;
-    loadModelFromBuffer(data: ArrayBuffer | Uint8Array, fileFormat: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
+    /**
+     * @param blobUrl Fetch URL for the main file (often a `blob:` URL); {@link ModelConfig.src} should stay the real file name for format detection.
+     */
+    loadLocalModel(blobUrl: string, modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadModel(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void, unsupportedMessage?: string): Promise<THREE.Object3D | void>;
+    loadModelFromBuffer(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
     /**
      * For dwg/dxf, we need to set font first.
      */

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

@@ -37,6 +37,11 @@ export declare class Model3d extends Model {
      * Gets the THREE.Object3D of this model.
      */
     getModelObject(): THREE.Object3D;
+    /**
+     * Clears cached bounds so the next {@link getBBox} recomputes from the scene graph
+     * (e.g. after transform gizmo edits).
+     */
+    invalidateBBox(): void;
     /**
      * Gets the bounding box of this model.
      */

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

@@ -67,5 +67,50 @@ export declare class GeometryUtils {
     static convertWidthLineToMeshGeometry(points: THREE.Vector2[], width: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
     static releaseGeometryManually(geometry: THREE.BufferGeometry): void;
     static getAdjacentNonRepeatPoints(points: THREE.Vector3[], epsilon?: number): THREE.Vector3[];
+    /**
+     * True when `attr` is a non-instanced per-vertex {@link THREE.BufferAttribute} or
+     * {@link THREE.InterleavedBufferAttribute} with `normalized: true` and an integer
+     * `TypedArray` backing (e.g. glTF normalized BYTE/SHORT or **KHR_mesh_quantization**).
+     * Use this to detect attributes already stored in normalized integer form (not only `position`).
+     */
+    static isNormalizedIntegerVertexAttribute(attr: unknown): boolean;
+    /**
+     * One axis of POSITION quantization: world coordinate → stored Int16 value in
+     * `[-32767, 32767]`, matching `KHR_mesh_quantization` with origin `center` and
+     * half-extent `halfExtent` on this axis.
+     */
+    static quantizePositionComponent(world: number, center: number, halfExtent: number): number;
+    /** Inverse of {@link GeometryUtils.quantizePositionComponent}: quantized → world units. */
+    static dequantizePositionComponent(quantized: number, center: number, halfExtent: number): number;
+    /**
+     * Quantizes geometry attributes in-place for KHR_mesh_quantization-style usage.
+     *
+     * Converts **position** (Float32 → Int16 normalized) when possible, and clears cached
+     * `boundingBox` / `boundingSphere` so world AABBs stay correct after baking the decode
+     * matrix into mesh transforms.
+     *
+     * If **position** already satisfies {@link GeometryUtils.isNormalizedIntegerVertexAttribute}
+     * (e.g. **KHR_mesh_quantization** from glTF), returns `null` and leaves the geometry unchanged
+     * (no double quantization).
+     *
+     * Other attributes (when present, non-instanced, backed by float arrays):
+     * **normal** → Int8 normalized, **uv** / **uv1–uv3** → Uint16 normalized ([0,1] only),
+     * **color** → Uint8 normalized ([0,1] only), **tangent** (vec4) → Int8 normalized.
+     * Does not touch **skinIndex** / **skinWeight** (skinning), morph targets, etc.
+     *
+     * @returns The position-decode `Matrix4` (`T(center) * S(halfExtents)`) when position was
+     *          quantized, or `null` when position was left unchanged. Right-multiply into the
+     *          mesh node matrix: `M_node_final = M_node_original * M_decode`.
+     */
+    static quantizeGeometry(geo: THREE.BufferGeometry): THREE.Matrix4 | null;
+    private static meshQuantMatScratch;
+    private static meshQuantInstanceTmp;
+    /**
+     * Walks `scene`, quantizes each unique mesh {@link THREE.BufferGeometry} (see
+     * {@link GeometryUtils.quantizeGeometry}), and bakes position decode into mesh
+     * transforms / instanced matrices (then syncs pq/s so {@link THREE.Object3D.matrixAutoUpdate}
+     * stays compatible with controls that edit position/quaternion/scale). Used after import.
+     */
+    static applyMeshQuantizationToSceneRoot(scene: THREE.Object3D): THREE.Object3D;
     static mergeBBoxes(bboxes: THREE.Box3[]): THREE.Box3[];
 }

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

@@ -12,5 +12,14 @@ export declare class TextureUtils {
      * Creates default environment texture
      */
     static createEnvTextureFromDataArray(pmremGenerator: THREE.PMREMGenerator | undefined, data?: Uint16Array, width?: number, height?: number): Promise<THREE.Texture>;
+    private static readonly MISSING_MAP_KEYS;
+    private static fallbackGrayMaterial?;
+    private static getFallbackGrayMaterial;
+    /**
+     * If any 2D map on a mesh material failed to load, replace the whole material with a shared gray MeshStandardMaterial.
+     */
+    static replaceBrokenMaterialMaps(root: THREE.Object3D): void;
+    private static materialHasBroken2DMap;
+    private static isTextureImageInvalid;
     private static readonly HDR_CITY_STREET_64x32;
 }