vis-core 0.33.7 → 0.33.9

package/dist/index.d.ts

@@ -1,63 +1,105 @@
-import { AmbientLightObject } from 'gl-draw';
-import { ArcObject } from 'gl-draw';
-import { ArcPathOptions } from 'gl-draw';
-import { ArcPoint } from 'gl-draw';
-import { ArcSpherePathOptions } from 'gl-draw';
-import { BaseObject } from 'gl-draw';
-import { baseObjectBounce } from 'gl-draw';
-import { baseObjectBounceIn } from 'gl-draw';
-import { baseObjectFadeIn } from 'gl-draw';
-import { baseObjectFadeOut } from 'gl-draw';
+import { AmbientLight as AmbientLight_2 } from 'three';
 import { BufferGeometry } from 'three';
+import { BufferGeometryEventMap } from 'three';
+import { Camera as Camera_2 } from 'three/webgpu';
+import { Camera as Camera_3 } from 'three';
+import { Color } from 'three';
 import { ColorRepresentation } from 'three';
-import { default as default_2 } from 'gl-draw';
-import { DirectionalLightObject } from 'gl-draw';
+import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer.js';
+import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer.js';
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer.js';
+import { CSS3DRenderer } from 'three/examples/jsm/renderers/CSS3DRenderer.js';
+import { CSS3DSprite } from 'three/examples/jsm/renderers/CSS3DRenderer.js';
+import { DataTexture } from 'three';
+import { DirectionalLight as DirectionalLight_2 } from 'three';
+import { Euler } from 'three';
 import { EventEmitter } from 'events';
-import { ExtrudePolygonObject } from 'gl-draw';
 import { FeatureCollection } from 'geojson';
+import { geoEquirectangular } from 'd3-geo';
 import { GeoJsonProperties } from 'geojson';
-import { GeometryDefinition } from 'gl-draw';
+import { geoMercator } from 'd3-geo';
 import { GeoProjection } from 'd3-geo';
-import { GroupObject } from 'gl-draw';
-import { HemisphereLightObject } from 'gl-draw';
+import { Group } from 'three';
+import { HemisphereLight as HemisphereLight_2 } from 'three';
+import { Intersection } from 'three';
 import { IUniform } from 'three';
-import { Lead } from 'gl-draw';
-import { LineObject } from 'gl-draw';
+import { Layers } from 'three/webgpu';
 import { Listener } from 'events';
+import { LoadingManager } from 'three';
+import { Material } from 'three';
+import { MaterialEventMap } from 'three';
+import { MaterialParameters } from 'three';
 import { Matrix4 } from 'three';
 import { Mesh } from 'three';
-import { MeshLineMaterial } from 'gl-draw';
-import { MeshObject } from 'gl-draw';
-import { ModelObject } from 'gl-draw';
+import { Mesh as Mesh_2 } from 'three/webgpu';
 import { MultiPolygon } from 'geojson';
-import { NodeObject } from 'gl-draw';
+import { Node as Node_2 } from 'three/webgpu';
+import { NodeMaterial } from 'three/webgpu';
+import { NormalBufferAttributes } from 'three';
 import { Object3D } from 'three';
-import { Pencil } from 'gl-draw';
-import { PointLightObject } from 'gl-draw';
+import { Object3D as Object3D_2 } from 'three/webgpu';
+import { Object3DEventMap } from 'three';
+import { Object3DJSON } from 'three';
+import { OrthographicCamera } from 'three';
+import { PerspectiveCamera } from 'three/webgpu';
+import { PerspectiveCamera as PerspectiveCamera_2 } from 'three';
+import { PointLight as PointLight_2 } from 'three';
 import { Polygon } from 'geojson';
 import { Position } from 'geojson';
-import { ProjectionOptions } from 'gl-draw';
-import { RectAreaLightObject } from 'gl-draw';
-import { remapSnapshotAnimationTracks } from 'gl-draw';
-import { ResourceRegistry } from 'gl-draw';
-import { RestoreBaseObjectOptions } from 'gl-draw';
-import { ReusableObjectResources } from 'gl-draw';
-import { SceneSnapshot } from 'gl-draw';
+import { Raycaster } from 'three/webgpu';
+import { RectAreaLight as RectAreaLight_2 } from 'three';
+import { RenderPipeline } from 'three/webgpu';
+import { RenderTarget } from 'three/webgpu';
+import { Scene } from 'three';
+import { Scene as Scene_2 } from 'three/webgpu';
 import { ShaderMaterial } from 'three';
-import { sinusoidalInOut } from 'gl-draw';
-import { SpotLightObject } from 'gl-draw';
-import { SpriteObject } from 'gl-draw';
-import { StructureResources } from 'gl-draw';
+import { ShaderMaterialJSON } from 'three';
+import { SpotLight as SpotLight_2 } from 'three';
+import { Sprite } from 'three';
+import { SpriteMaterial } from 'three';
 import { Texture } from 'three';
-import * as THREE from 'three';
-import { timeOut } from 'gl-draw';
-import { TubeObject } from 'gl-draw';
+import { TextureEventMap } from 'three';
+import * as THREE from 'three/webgpu';
+import * as _THREE from 'three';
+import { Timer } from 'three/webgpu';
+import { TransformControls } from 'three/examples/jsm/controls/TransformControls.js';
 import { default as TWEEN } from 'three/examples/jsm/libs/tween.module.js';
 import { Tween as Tween_2 } from 'three/examples/jsm/libs/tween.module.js';
-import { TweenOptions } from 'gl-draw';
-import { Vector2 } from 'three';
+import { Vector2 } from 'three/webgpu';
+import { Vector2 as Vector2_2 } from 'three';
 import { Vector3 } from 'three';
+import { Vector3 as Vector3_2 } from 'three/webgpu';
 import { Vector3Tuple } from 'three';
+import { VideoTexture } from 'three';
+import { ViewHelper } from 'three/examples/jsm/helpers/ViewHelper.js';
+import { WebGPURenderer } from 'three/webgpu';
+import { WorkerPool } from 'esus-lite';
+
+declare const ACTION: Readonly<{
+    readonly NONE: 0;
+    readonly ROTATE: 1;
+    readonly TRUCK: 2;
+    readonly OFFSET: 4;
+    readonly DOLLY: 8;
+    readonly ZOOM: 16;
+    readonly TOUCH_ROTATE: 32;
+    readonly TOUCH_TRUCK: 64;
+    readonly TOUCH_OFFSET: 128;
+    readonly TOUCH_DOLLY: 256;
+    readonly TOUCH_ZOOM: 512;
+    readonly TOUCH_DOLLY_TRUCK: 1024;
+    readonly TOUCH_DOLLY_OFFSET: 2048;
+    readonly TOUCH_DOLLY_ROTATE: 4096;
+    readonly TOUCH_ZOOM_TRUCK: 8192;
+    readonly TOUCH_ZOOM_OFFSET: 16384;
+    readonly TOUCH_ZOOM_ROTATE: 32768;
+    readonly SCREEN_PAN: 65536;
+    readonly TOUCH_SCREEN_PAN: 131072;
+    readonly TOUCH_DOLLY_SCREEN_PAN: 262144;
+    readonly TOUCH_ZOOM_SCREEN_PAN: 524288;
+}>;
+
+declare type ACTION = number;
 
 export declare const adcodeAll: AdcodeRecords;
 
@@ -80,6 +122,22 @@ declare class AmbientLight extends AmbientLightObject {
     constructor(...options: ConstructorParameters<typeof AmbientLightObject>);
 }
 
+declare class AmbientLightObject extends BaseObject<AmbientLight_2> {
+    objectType: string;
+    constructor(lightOrColor?: AmbientLight_2 | string | number, intensity?: number);
+}
+
+/** Tweens owned by one renderer, including paused animations. */
+declare class AnimationScope {
+    private readonly group;
+    private readonly active;
+    private disposed;
+    get isDisposed(): boolean;
+    create<T extends Record<string, any>>(state: T): Tween_2<T>;
+    update(time?: number): void;
+    dispose(): void;
+}
+
 export declare namespace animationUtils {
     export {
         timeOut,
@@ -97,17 +155,92 @@ export declare function appendObjectDocument(before: VisSceneDocument, sceneId:
 
 export declare function appendScenesDocument(before: VisSceneDocument, scenes: readonly SceneViewportDocument[], materials?: readonly MaterialAsset[], prefabs?: readonly PrefabAsset[]): VisSceneDocument;
 
-export { ArcPathOptions }
+declare type ArcCurve = _THREE.CubicBezierCurve3 | SphereArcCurve;
+
+declare class ArcObject extends LineObject {
+    objectType: string;
+    options: ArcOptions;
+    constructor(options: ArcOptions);
+    create(): Promise<void>;
+    /** Internal/local-space curve used for rendering, editor handles and snapshots. */
+    getCurve(): ArcCurve;
+    /** Set four world-space Bézier controls; persisted coordinates remain local. */
+    setControlPoints(points: readonly [ArcPoint, ArcPoint, ArcPoint, ArcPoint]): void;
+    /** Set a world-space path without changing this object or its parent transforms. */
+    setPath(from: ArcPoint, to: ArcPoint, options: ArcPathOptions): void;
+    /** Exact radial lift above the short great circle; preserves every object transform. */
+    setSpherePath(from: ArcPoint, to: ArcPoint, options: ArcSpherePathOptions): void;
+    private worldToLocalMatrix;
+    private validatedNodes;
+    private setWorldControls;
+    private getPickPathOptions;
+    private syncPickPathOptions;
+    private updatePickTargetGeometry;
+    pickTube: TubeObject | null;
+    private pickTargetVersion;
+    private pickBindings;
+    addPickTarget(radius?: number, show?: boolean): Promise<TubeObject | undefined>;
+    /** Restored picking children are adopted instead of allocating a duplicate tube. */
+    rebuildFromScene(): Promise<void>;
+    dispose(): void;
+    protected createPointerBinding(type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): () => void;
+    setColor(color: string): void;
+    animateIn({ duration, delay, repeat, onComplete, onRepeat, }?: {
+        duration?: number;
+        delay?: number;
+        repeat?: number;
+        onComplete?: (...args: any[]) => void;
+        onRepeat?: (count: number) => void;
+    }): void;
+    render(): void;
+}
+
+declare interface ArcOptions extends NonNullable<ConstructorParameters<typeof LineObject>[0]> {
+    from: number[];
+    to: number[];
+    control1?: number[];
+    control2?: number[];
+    spherePath?: ArcSpherePath;
+    radius?: number;
+    globe?: boolean;
+    color?: string;
+    lineWidth?: number;
+    offsetLoop?: boolean;
+}
+
+export declare interface ArcPathOptions {
+    /** Maximum displacement from the endpoint segment along `up`, in world units. */
+    height: number;
+    /** World-space lift direction; normalized internally. Defaults to positive Z. */
+    up?: ArcPoint;
+    setPointWidth?: (progress: number) => number;
+}
+
+export declare type ArcPoint = _THREE.Vector3 | readonly number[];
 
-export { ArcPoint }
+/** A sphere frame in Arc-local coordinates. Its basis retains world-unit lengths. */
+declare interface ArcSpherePath {
+    matrix: number[];
+    angle: number;
+    radius: number;
+    height: number;
+}
 
-export { ArcSpherePathOptions }
+export declare interface ArcSpherePathOptions {
+    /** World-space sphere center. Both endpoints must lie on the same sphere. */
+    center: ArcPoint;
+    /** Maximum distance above the sphere surface, in world units. Zero follows its surface. */
+    height: number;
+    /** World-space circle-plane normal for coincident or antipodal endpoints. */
+    normal?: ArcPoint;
+    setPointWidth?: (progress: number) => number;
+}
 
 declare class Area extends GroupObject {
     objectType: string;
-    options: Options_8;
+    options: Options_21;
     area: ExtrudePolygonObject[];
-    constructor(options: Options_8);
+    constructor(options: Options_21);
     create(): Promise<void>;
     rebuildFromScene(): void;
 }
@@ -122,6 +255,88 @@ export declare function assertSceneManifest(value: unknown): asserts value is Vi
 
 export declare function assertSupportedSceneDocument(value: unknown): void;
 
+declare interface Asset extends AssetOptions {
+    src: string;
+    cacheData?: any;
+}
+
+declare interface AssetOptions {
+    cache?: boolean;
+    dracoPath?: string;
+    anisotropy?: number;
+    type?: string;
+    responseType?: string;
+}
+
+declare class AttributesWorker {
+    options: Options_13 & {
+        maxWorkers: number;
+        cacheVersion: string;
+        dbName: string;
+        maxCacheSize: number;
+    };
+    pool: WorkerPool;
+    cacheManager: CacheManager;
+    private resources?;
+    private disposed;
+    private assertActive;
+    constructor(options?: Options_13, resources?: ResourceRegistry);
+    geoGeometry(type: 'extrudePolygon', options: GeoGeometryOptions & {
+        mesaage: ExtrudePolygonMessage;
+    }): Promise<BufferGeometry>;
+    geoGeometry(type: 'conicPolygon', options: GeoGeometryOptions & {
+        mesaage: ConicPolygonMessage;
+    }): Promise<BufferGeometry>;
+    geoGeometry(type: 'conicLine', options: GeoGeometryOptions & {
+        mesaage: ConicLineMessage;
+    }): Promise<BufferGeometry>;
+    geoGeometry(type: 'line', options: GeoGeometryOptions & {
+        mesaage: LineMessage;
+    }): Promise<BufferGeometry>;
+    getCachedGeometry(options: Pick<GeoGeometryOptions, 'cacheKey'>): Promise<ReturnType<typeof _default> | null>;
+    private buildGeometry;
+    saveCache(): Promise<void>;
+    /**
+     * 批量保存待更新的元数据
+     */
+    flushMetadata(): Promise<void>;
+    /**
+     * 获取缓存统计信息
+     */
+    getCacheStats(): Promise<{
+        total: number;
+        maxSize: number;
+        usage: number;
+        items: {
+            key: IDBValidKey;
+            metadata: CacheMetadata;
+        }[];
+    }>;
+    /**
+     * 手动清空所有缓存
+     */
+    clearCache(): Promise<void>;
+    /**
+     * 检查存储配额使用情况
+     */
+    checkStorageQuota(): Promise<{
+        usage: number;
+        quota: number;
+        percentUsed: number;
+    } | null>;
+    flattenCoordinates(coordinatesArr: number[][][], metaArray?: number[][], _globalMeta?: number[], useFloat64Array?: boolean): {
+        flat: Float64Array | Float32Array;
+        lengths: number[];
+        metaLength: number;
+    };
+    dispose(): void;
+}
+
+declare interface AverageData {
+    logs: number[];
+    graph: number[];
+}
+
 export declare type Base = Base_2;
 
 declare type Base_2 = Base_3;
@@ -138,9 +353,9 @@ declare class Base_3 extends Camera {
     options: BaseOptions;
     showState: boolean;
     lead: Lead;
-    sceneResources: default_2['sceneResources'];
+    sceneResources: Pencil['sceneResources'];
     tier0: boolean;
-    roomEnvMap?: THREE.Texture;
+    roomEnvMap?: _THREE.Texture;
     private roomEnvLease?;
     visName: string;
     private detectRes?;
@@ -160,9 +375,9 @@ declare class Base_3 extends Camera {
     instantiatePrefab(keyOrAssetId: string, options?: InstantiatePrefabOptions): Promise<BaseObject>;
     private cancelPrefabOperations;
     constructor(options: BaseOptions);
-    getMaterialGroup(group: string): Record<string, THREE.Material<THREE.MaterialEventMap>> | null;
-    registerMaterialGroup(group: string, materials: Record<string, THREE.Material | null>): void;
-    copyMaterialGroup(source: string, target: string): Record<string, THREE.Material<THREE.MaterialEventMap>>;
+    getMaterialGroup(group: string): Record<string, _THREE.Material<_THREE.MaterialEventMap>> | null;
+    registerMaterialGroup(group: string, materials: Record<string, _THREE.Material | null>): void;
+    copyMaterialGroup(source: string, target: string): Record<string, _THREE.Material<_THREE.MaterialEventMap>>;
     private getDetectRes;
     private getQueryOverrides;
     private getEffectiveLogarithmicDepthBuffer;
@@ -186,7 +401,7 @@ declare class Base_3 extends Camera {
     /** 子类扩展点：释放额外引用和监听；页面资源由 Base 统一释放。 */
     protected onDispose(): void;
     protected get objectTypes(): Record<string, any>;
-    protected get defaultCameraUp(): THREE.Vector3;
+    protected get defaultCameraUp(): _THREE.Vector3;
     private createRuntime;
     private reportScriptError;
     private sceneActive;
@@ -201,7 +416,7 @@ declare class Base_3 extends Camera {
     releasePencilOwnership(): void;
     private initSceneUserData;
     /** Save a partial object state and apply its effects without replaying other state. */
-    setObjectState(object: BaseObject, patch: Record<string, any>): BaseObject<THREE.Object3D<THREE.Object3DEventMap>>;
+    setObjectState(object: BaseObject, patch: Record<string, any>): BaseObject<_THREE.Object3D<_THREE.Object3DEventMap>>;
     applyObjectState(object: BaseObject, state?: Record<string, any>): void;
     /** 场景页提交后的默认入场动画；地图可覆盖为更有空间感的过渡。 */
     playEnterTransition({ duration, onPrepared, }: SceneEnterTransitionOptions): Promise<void>;
@@ -228,8 +443,8 @@ declare class Base_3 extends Camera {
     hide(): void;
     exportScene(): SceneSnapshot;
     exportBaseObject(baseObject: BaseObject): SceneSnapshot;
-    restoreBaseObject(data: string | THREE.Object3DJSON, target?: BaseObject, objectsMap?: Record<string, any>, signal?: AbortSignal, options?: RestoreBaseObjectOptions): Promise<BaseObject<THREE.Object3D<THREE.Object3DEventMap>>>;
-    restoreScene(str: string | THREE.Object3DJSON, objectsMap?: Record<string, any>, restoreOptions?: RestoreBaseObjectOptions): Promise<void>;
+    restoreBaseObject(data: string | _THREE.Object3DJSON, target?: BaseObject, objectsMap?: Record<string, any>, signal?: AbortSignal, options?: RestoreBaseObjectOptions): Promise<BaseObject<_THREE.Object3D<_THREE.Object3DEventMap>>>;
+    restoreScene(str: string | _THREE.Object3DJSON, objectsMap?: Record<string, any>, restoreOptions?: RestoreBaseObjectOptions): Promise<void>;
     getClassRefByType(type: string): typeof BaseObject;
     addGroup(): Promise< GroupObject>;
     addCSS2D(dom: HTMLElement, options?: {
@@ -244,21 +459,152 @@ declare class Base_3 extends Camera {
         target?: BaseObject;
     }): Promise< NodeObject>;
     private addNode;
-    getRoomEnvMap(): THREE.Texture<unknown, THREE.TextureEventMap>;
+    getRoomEnvMap(): _THREE.Texture<unknown, _THREE.TextureEventMap>;
     getScreenPosition(x: number, y: number, z: number): {
         x: number;
         y: number;
     };
-    uuidByObject(object: THREE.Object3D): string | undefined;
-    objectByUuid(key: string): THREE.Object3D<THREE.Object3DEventMap>;
+    uuidByObject(object: _THREE.Object3D): string | undefined;
+    objectByUuid(key: string): _THREE.Object3D<_THREE.Object3DEventMap>;
     uuidByBaseObject(object: BaseObject): string;
     baseObjectByUuid(uuid: string): BaseObject;
     /** Compatibility method name; key is the persisted UUID. */
     baseObjectByKey(key: string): BaseObject;
-    baseObjectByName(name: string): BaseObject<THREE.Object3D<THREE.Object3DEventMap>> | undefined;
+    baseObjectByName(name: string): BaseObject<_THREE.Object3D<_THREE.Object3DEventMap>> | undefined;
     dispose(): void;
 }
 
+declare class BaseObject<T extends Object3D = Object3D> extends UseMaterial {
+    /** One persisted identity, owned by the underlying Three.js object. */
+    get key(): string;
+    set key(value: string);
+    get uuid(): string;
+    set uuid(value: string);
+    get name(): string;
+    set name(v: string);
+    objectType: string;
+    options: any;
+    private _keyType;
+    get keyType(): string;
+    set keyType(v: string);
+    pencil: Pencil;
+    lead: Lead_2;
+    sceneResources: SceneResources_2;
+    object3d: T;
+    userData: Record<string, any>;
+    isInstantiate: boolean;
+    isBloom: boolean;
+    isBaseObject: boolean;
+    /** Bound resources are SDK-owned unless the caller explicitly borrows them. */
+    resourceOwnership: ResourceOwnership;
+    constructor(object3d: T, options?: {
+        ownership?: ResourceOwnership;
+    });
+    get parent(): BaseObject | null;
+    get children(): BaseObject<Object3D< Object3DEventMap>>[];
+    get position(): Vector3;
+    get rotation(): Euler;
+    get scale(): Vector3;
+    lookAt(vector: Vector3): void;
+    lookAt(x: number, y: number, z: number): void;
+    draw<C extends new (...args: any[]) => BaseObject>(ClassRef: C, ...args: ConstructorParameters<C>): Promise<InstanceType<C>>;
+    add(...objects: (Object3D | BaseObject)[]): void;
+    remove(...object: Object3D[]): void;
+    get visible(): boolean;
+    /**
+     * 检查是否实际可见（自己和所有祖先都 visible）
+     */
+    isActuallyVisible(): boolean;
+    create(): void;
+    /** Optional allocation boundary for nested creation and failure rollback. */
+    createResource<R extends object>(factory: () => R): R;
+    render(): void;
+    update(_delta: number, _elapsed: number): void;
+    resize(_width: number, _height: number): void;
+    show(): this;
+    hide(): this;
+    /**
+     * 递归禁用 layers（不管子级自己的 visible 状态，全部 disable）
+     */
+    protected _disableLayersRecursive(): void;
+    /**
+     * 递归启用 layers（只有自己 visible=true 时才 enable 并继续递归）
+     */
+    protected _enableLayersRecursive(): void;
+    attach(...args: BaseObject[]): this;
+    getSize(): {
+        min: Vector3;
+        max: Vector3;
+        size: Vector3;
+        center: Vector3;
+    };
+    setTop(onTop: number): void;
+    traverse(fn: (o: BaseObject) => void): void;
+    instantiate(ops?: {
+        target?: BaseObject;
+        recursive?: boolean;
+        instancedAttr?: {
+            position: Vector3 | number[] | [number, number, number];
+            scale?: Vector3 | number[] | [number, number, number];
+        }[];
+        cloneMaterial?: boolean;
+    }): Promise<this>;
+    erase(): void;
+    setKey(value: string | {
+        keyType?: string;
+        uuid?: string;
+    }): string;
+    handleMaterialChange(_mat: Material | Material[] | null): void;
+    enableBloom(traverse?: boolean): void;
+    disableBloom(traverse?: boolean): void;
+    private isDispose;
+    private disposalRequested;
+    /** Internal: Resource cleanup waits until create() has finished allocating. */
+    creationPending: boolean;
+    get isDisposed(): boolean;
+    dispose(): void;
+}
+
+declare const baseObjectBounce: (obj: BaseObject, up: string | undefined, to: number) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<void>;
+    stop: () => void;
+};
+
+declare const baseObjectBounceIn: (obj: BaseObject, up?: string) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<void>;
+    stop: () => void;
+};
+
+declare const baseObjectFadeIn: (obj: BaseObject) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<void>;
+    stop: () => void;
+};
+
+declare const baseObjectFadeOut: (obj: BaseObject) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<void>;
+    stop: () => void;
+};
+
 declare interface BaseOptions {
     container: HTMLElement;
     assetsPrefix?: string;
@@ -293,6 +639,13 @@ export declare interface BindMaterialAssetOptions {
 /** Bind explicit slots; no render graph is exported to discover the changed rows. */
 export declare function bindMaterialSlots(document: VisSceneDocument, sceneId: string, assignments: readonly MaterialSlotAssignment[], optionReplacements?: ReadonlyMap<string, ReadonlyMap<string, string>>, optionAssetId?: string): VisSceneDocument;
 
+declare interface BloomParams {
+    threshold: number;
+    strength: number;
+    radius: number;
+    bloomAlphaType: 1 | 0.5 | 0;
+}
+
 declare class Box extends MeshObject {
     objectType: string;
     create(): void;
@@ -300,21 +653,98 @@ declare class Box extends MeshObject {
 
 declare class Building extends GroupObject {
     objectType: string;
-    options: Options_6;
-    constructor(options: Options_6);
+    options: Options_19;
+    constructor(options: Options_19);
     create(): Promise<void>;
     rebuildFromScene(): void;
     private gradientMaterials;
-    worldPositionZ: {
-        value: number;
-    };
+    worldPositionZ: THREE.UniformNode<"float", number>;
     sideGradient(color?: string, maxGradientHeight?: number): void;
     update(): void;
 }
 
+declare class CacheManager {
+    private store;
+    private metadataStore;
+    private pendingMetadataUpdates;
+    private cacheObj;
+    private options;
+    private operation;
+    private generation;
+    /** Serialize writes to the two stores; a rejected write must not block retries. */
+    private enqueue;
+    constructor(options: CacheManagerOptions);
+    /**
+     * 添加缓存到内存队列
+     */
+    addToCache(cacheKey: string, data: any): void;
+    /**
+     * 记录待更新的缓存元数据（非阻塞）
+     */
+    recordMetadataUpdate(cacheKey: string, size?: number): void;
+    /**
+     * 批量保存待更新的元数据
+     */
+    flushMetadata(): Promise<void>;
+    private flushMetadataNow;
+    /**
+     * 清理最少使用的缓存（LRU策略）
+     */
+    private evictLRUCache;
+    /**
+     * 从缓存中获取数据
+     */
+    get<T = any>(cacheKey: string): Promise<T | undefined>;
+    /**
+     * 保存内存缓存到 IndexedDB
+     */
+    saveCache(): Promise<void>;
+    private saveCacheNow;
+    /**
+     * 获取缓存统计信息
+     */
+    getCacheStats(): Promise<{
+        total: number;
+        maxSize: number;
+        usage: number;
+        items: Array<{
+            key: IDBValidKey;
+            metadata: CacheMetadata;
+        }>;
+    }>;
+    /**
+     * 手动清空所有缓存
+     */
+    clearCache(): Promise<void>;
+    private clearStoredCache;
+    /**
+     * 检查存储配额使用情况
+     */
+    checkStorageQuota(): Promise<{
+        usage: number;
+        quota: number;
+        percentUsed: number;
+    } | null>;
+    /**
+     * 清理内存和待更新队列
+     */
+    dispose(): void;
+}
+
+declare interface CacheManagerOptions {
+    dbName: string;
+    maxCacheSize: number;
+    cacheVersion: string;
+}
+
+declare interface CacheMetadata {
+    lastAccessed: number;
+    accessCount: number;
+}
+
 declare class Camera extends Event_2 {
     container: HTMLElement;
-    pencil: default_2;
+    pencil: Pencil;
     cameraState: Record<string, number[]>;
     cameraStateActive: string;
     setSaveCamera(type: string): void;
@@ -325,17 +755,1022 @@ declare class Camera extends Event_2 {
     dollyTo(distance: number | `+=${number}` | `-=${number}` | `*=${number}` | `/=${number}`, enableTransition?: boolean, smoothTime?: number): Promise<void>;
     absoluteAngle(targetAngle: number, sourceAngle: number): number;
     lookAtTarget(ops: {
-        target?: THREE.Vector3;
+        target?: _THREE.Vector3;
         distance?: number;
         polarAngle?: number;
         azimuthAngle?: number;
     }, enableTransition?: boolean, smoothTime?: number): Promise<void>;
     paddingInCssPixel(obj: BaseObject, top: number, right: number, bottom: number, left: number, enableTransition: boolean): Promise<void[]>;
     resetCamera(enableTransition?: boolean, smoothTime?: number): Promise<void>;
-    unproject(e: MouseEvent, targetZ?: number): THREE.Vector3;
+    unproject(e: MouseEvent, targetZ?: number): _THREE.Vector3;
     dispose(): void;
 }
 
+declare class CameraControls extends EventDispatcher {
+    /**
+     * Injects THREE as the dependency. You can then proceed to use CameraControls.
+     *
+     * e.g
+     * ```javascript
+     * CameraControls.install( { THREE: THREE } );
+     * ```
+     *
+     * Note: If you do not wish to use enter three.js to reduce file size(tree-shaking for example), make a subset to install.
+     *
+     * ```js
+     * import {
+     * 	Vector2,
+     * 	Vector3,
+     * 	Vector4,
+     * 	Quaternion,
+     * 	Matrix4,
+     * 	Spherical,
+     * 	Box3,
+     * 	Sphere,
+     * 	Raycaster,
+     * 	MathUtils,
+     * } from 'three';
+     *
+     * const subsetOfTHREE = {
+     * 	Vector2   : Vector2,
+     * 	Vector3   : Vector3,
+     * 	Vector4   : Vector4,
+     * 	Quaternion: Quaternion,
+     * 	Matrix4   : Matrix4,
+     * 	Spherical : Spherical,
+     * 	Box3      : Box3,
+     * 	Sphere    : Sphere,
+     * 	Raycaster : Raycaster,
+     * };
+
+     * CameraControls.install( { THREE: subsetOfTHREE } );
+     * ```
+     * @category Statics
+     */
+    static install(libs: { THREE: THREESubset }): void;
+    /*
+    * list all ACTIONs
+    * @category Statics
+    */
+    static readonly ACTION: typeof ACTION;
+    /**
+     * Minimum vertical angle in radians.
+     * The angle has to be between `0` and `.maxPolarAngle` inclusive.
+     * The default value is `0`.
+     *
+     * e.g.
+     * ```
+     * cameraControls.maxPolarAngle = 0;
+     * ```
+     * @category Properties
+     */
+    minPolarAngle: number;
+    /**
+     * Maximum vertical angle in radians.
+     * The angle has to be between `.maxPolarAngle` and `Math.PI` inclusive.
+     * The default value is `Math.PI`.
+     *
+     * e.g.
+     * ```
+     * cameraControls.maxPolarAngle = Math.PI;
+     * ```
+     * @category Properties
+     */
+    maxPolarAngle: number;
+    /**
+     * Minimum horizontal angle in radians.
+     * The angle has to be less than `.maxAzimuthAngle`.
+     * The default value is `- Infinity`.
+     *
+     * e.g.
+     * ```
+     * cameraControls.minAzimuthAngle = - Infinity;
+     * ```
+     * @category Properties
+     */
+    minAzimuthAngle: number;
+    /**
+     * Maximum horizontal angle in radians.
+     * The angle has to be greater than `.minAzimuthAngle`.
+     * The default value is `Infinity`.
+     *
+     * e.g.
+     * ```
+     * cameraControls.maxAzimuthAngle = Infinity;
+     * ```
+     * @category Properties
+     */
+    maxAzimuthAngle: number;
+    /**
+     * Minimum distance for dolly. The value must be higher than `0`. Default is `Number.EPSILON`.
+     * PerspectiveCamera only.
+     * @category Properties
+     */
+    minDistance: number;
+    /**
+     * Maximum distance for dolly. The value must be higher than `minDistance`. Default is `Infinity`.
+     * PerspectiveCamera only.
+     * @category Properties
+     */
+    maxDistance: number;
+    /**
+     * `true` to enable Infinity Dolly for wheel and pinch. Use this with `minDistance` and `maxDistance`
+     * If the Dolly distance is less (or over) than the `minDistance` (or `maxDistance`), `infinityDolly` will keep the distance and pushes the target position instead.
+     * @category Properties
+     */
+    infinityDolly: boolean;
+    /**
+     * Minimum camera zoom.
+     * @category Properties
+     */
+    minZoom: number;
+    /**
+     * Maximum camera zoom.
+     * @category Properties
+     */
+    maxZoom: number;
+    /**
+     * Approximate time in seconds to reach the target. A smaller value will reach the target faster.
+     * @category Properties
+     */
+    smoothTime: number;
+    /**
+     * the smoothTime while dragging
+     * @category Properties
+     */
+    draggingSmoothTime: number;
+    /**
+     * Max transition speed in unit-per-seconds
+     * @category Properties
+     */
+    maxSpeed: number;
+    /**
+     * Speed of azimuth (horizontal) rotation.
+     * @category Properties
+     */
+    azimuthRotateSpeed: number;
+    /**
+     * Speed of polar (vertical) rotation.
+     * @category Properties
+     */
+    polarRotateSpeed: number;
+    /**
+     * Speed of mouse-wheel dollying.
+     * @category Properties
+     */
+    dollySpeed: number;
+    /**
+     * `true` to invert direction when dollying or zooming via drag
+     * @category Properties
+     */
+    dollyDragInverted: boolean;
+    /**
+     * Speed of drag for truck and pedestal.
+     * @category Properties
+     */
+    truckSpeed: number;
+    /**
+     * `true` to enable Dolly-in to the mouse cursor coords.
+     * @category Properties
+     */
+    dollyToCursor: boolean;
+    /**
+     * @category Properties
+     */
+    dragToOffset: boolean;
+    /**
+     * Friction ratio of the boundary.
+     * @category Properties
+     */
+    boundaryFriction: number;
+    /**
+     * Controls how soon the `rest` event fires as the camera slows.
+     * @category Properties
+     */
+    restThreshold: number;
+    /**
+     * An array of Meshes to collide with camera.
+     * Be aware colliderMeshes may decrease performance. The collision test uses 4 raycasters from the camera since the near plane has 4 corners.
+     * @category Properties
+     */
+    colliderMeshes: _THREE.Object3D[];
+    /**
+     * User's mouse input config.
+     *
+     * | button to assign      | behavior |
+     * | --------------------- | -------- |
+     * | `mouseButtons.left`   | `CameraControls.ACTION.ROTATE`* \| `CameraControls.ACTION.TRUCK` \| `CameraControls.ACTION.OFFSET` \| `CameraControls.ACTION.DOLLY` \| `CameraControls.ACTION.ZOOM` \| `CameraControls.ACTION.NONE` |
+     * | `mouseButtons.right`  | `CameraControls.ACTION.ROTATE` \| `CameraControls.ACTION.TRUCK`* \| `CameraControls.ACTION.OFFSET` \| `CameraControls.ACTION.DOLLY` \| `CameraControls.ACTION.ZOOM` \| `CameraControls.ACTION.NONE` |
+     * | `mouseButtons.wheel` ¹ | `CameraControls.ACTION.ROTATE` \| `CameraControls.ACTION.TRUCK` \| `CameraControls.ACTION.OFFSET` \| `CameraControls.ACTION.DOLLY` \| `CameraControls.ACTION.ZOOM` \| `CameraControls.ACTION.NONE` |
+     * | `mouseButtons.middle` ² | `CameraControls.ACTION.ROTATE` \| `CameraControls.ACTION.TRUCK` \| `CameraControls.ACTION.OFFSET` \| `CameraControls.ACTION.DOLLY`* \| `CameraControls.ACTION.ZOOM` \| `CameraControls.ACTION.NONE` |
+     *
+     * 1. Mouse wheel event for scroll "up/down" on mac "up/down/left/right"
+     * 2. Mouse click on wheel event "button"
+     * - \* is the default.
+     * - The default of `mouseButtons.wheel` is:
+     *   - `DOLLY` for Perspective camera.
+     *   - `ZOOM` for Orthographic camera, and can't set `DOLLY`.
+     * @category Properties
+     */
+    mouseButtons: MouseButtons;
+    /**
+     * User's touch input config.
+     *
+     * | fingers to assign     | behavior |
+     * | --------------------- | -------- |
+     * | `touches.one` | `CameraControls.ACTION.TOUCH_ROTATE`* \| `CameraControls.ACTION.TOUCH_TRUCK` \| `CameraControls.ACTION.TOUCH_OFFSET` \| `CameraControls.ACTION.DOLLY` | `CameraControls.ACTION.ZOOM` | `CameraControls.ACTION.NONE` |
+     * | `touches.two` | `ACTION.TOUCH_DOLLY_TRUCK` \| `ACTION.TOUCH_DOLLY_OFFSET` \| `ACTION.TOUCH_DOLLY_ROTATE` \| `ACTION.TOUCH_ZOOM_TRUCK` \| `ACTION.TOUCH_ZOOM_OFFSET` \| `ACTION.TOUCH_ZOOM_ROTATE` \| `ACTION.TOUCH_DOLLY` \| `ACTION.TOUCH_ZOOM` \| `CameraControls.ACTION.TOUCH_ROTATE` \| `CameraControls.ACTION.TOUCH_TRUCK` \| `CameraControls.ACTION.TOUCH_OFFSET` \| `CameraControls.ACTION.NONE` |
+     * | `touches.three` | `ACTION.TOUCH_DOLLY_TRUCK` \| `ACTION.TOUCH_DOLLY_OFFSET` \| `ACTION.TOUCH_DOLLY_ROTATE` \| `ACTION.TOUCH_ZOOM_TRUCK` \| `ACTION.TOUCH_ZOOM_OFFSET` \| `ACTION.TOUCH_ZOOM_ROTATE` \| `CameraControls.ACTION.TOUCH_ROTATE` \| `CameraControls.ACTION.TOUCH_TRUCK` \| `CameraControls.ACTION.TOUCH_OFFSET` \| `CameraControls.ACTION.NONE` |
+     *
+     * - \* is the default.
+     * - The default of `touches.two` and `touches.three` is:
+     *   - `TOUCH_DOLLY_TRUCK` for Perspective camera.
+     *   - `TOUCH_ZOOM_TRUCK` for Orthographic camera, and can't set `TOUCH_DOLLY_TRUCK` and `TOUCH_DOLLY`.
+     * @category Properties
+     */
+    touches: Touches;
+    /**
+     * Force cancel user dragging.
+     * @category Methods
+     */
+    cancel: () => void;
+    /**
+     * Still an experimental feature.
+     * This could change at any time.
+     * @category Methods
+     */
+    lockPointer: () => void;
+    /**
+     * Still an experimental feature.
+     * This could change at any time.
+     * @category Methods
+     */
+    unlockPointer: () => void;
+    protected _enabled: boolean;
+    protected _camera: _THREE.PerspectiveCamera | _THREE.OrthographicCamera;
+    protected _yAxisUpSpace: _THREE.Quaternion;
+    protected _yAxisUpSpaceInverse: _THREE.Quaternion;
+    protected _state: ACTION;
+    protected _domElement?: HTMLElement;
+    protected _viewport: _THREE.Vector4 | null;
+    protected _target: _THREE.Vector3;
+    protected _targetEnd: _THREE.Vector3;
+    protected _focalOffset: _THREE.Vector3;
+    protected _focalOffsetEnd: _THREE.Vector3;
+    protected _spherical: _THREE.Spherical;
+    protected _sphericalEnd: _THREE.Spherical;
+    protected _lastDistance: number;
+    protected _zoom: number;
+    protected _zoomEnd: number;
+    protected _lastZoom: number;
+    protected _cameraUp0: _THREE.Vector3;
+    protected _target0: _THREE.Vector3;
+    protected _position0: _THREE.Vector3;
+    protected _zoom0: number;
+    protected _focalOffset0: _THREE.Vector3;
+    protected _dollyControlCoord: _THREE.Vector2;
+    protected _changedDolly: number;
+    protected _changedZoom: number;
+    protected _nearPlaneCorners: [
+    _THREE.Vector3,
+    _THREE.Vector3,
+    _THREE.Vector3,
+    _THREE.Vector3,
+    ];
+    protected _hasRested: boolean;
+    protected _boundary: _THREE.Box3;
+    protected _boundaryEnclosesCamera: boolean;
+    protected _needsUpdate: boolean;
+    protected _updatedLastTime: boolean;
+    protected _elementRect: DOMRect;
+    protected _isDragging: boolean;
+    protected _dragNeedsUpdate: boolean;
+    protected _activePointers: PointerInput[];
+    protected _lockedPointer: PointerInput | null;
+    protected _interactiveArea: DOMRect;
+    protected _isUserControllingRotate: boolean;
+    protected _isUserControllingDolly: boolean;
+    protected _isUserControllingTruck: boolean;
+    protected _isUserControllingOffset: boolean;
+    protected _isUserControllingZoom: boolean;
+    protected _lastDollyDirection: DOLLY_DIRECTION;
+    protected _thetaVelocity: Ref;
+    protected _phiVelocity: Ref;
+    protected _radiusVelocity: Ref;
+    protected _targetVelocity: _THREE.Vector3;
+    protected _focalOffsetVelocity: _THREE.Vector3;
+    protected _zoomVelocity: Ref;
+    /**
+     * Creates a `CameraControls` instance.
+     *
+     * Note:
+     * You **must install** three.js before using camera-controls. see [#install](#install)
+     * Not doing so will lead to runtime errors (`undefined` references to THREE).
+     *
+     * e.g.
+     * ```
+     * CameraControls.install( { THREE } );
+     * const cameraControls = new CameraControls( camera, domElement );
+     * ```
+     *
+     * @param camera A `THREE.PerspectiveCamera` or `THREE.OrthographicCamera` to be controlled.
+     * @param domElement A `HTMLElement` for the draggable area, usually `renderer.domElement`.
+     * @category Constructor
+     */
+    constructor(
+    camera: _THREE.PerspectiveCamera | _THREE.OrthographicCamera,
+    domElement?: HTMLElement,
+    );
+    /*
+    * The camera to be controlled
+    * @category Properties
+    */
+    camera: _THREE.PerspectiveCamera | _THREE.OrthographicCamera;
+    /*
+    * Whether or not the controls are enabled.
+    * `false` to disable user dragging/touch-move, but all methods works.
+    * @category Properties
+    */
+    enabled: boolean;
+    /*
+    * Returns `true` if the controls are active updating.
+    * readonly value.
+    * @category Properties
+    */
+    readonly active: boolean;
+    /*
+    * Getter for the current `ACTION`.
+    * readonly value.
+    * @category Properties
+    */
+    readonly currentAction: ACTION;
+    /*
+    * get/set Current distance.
+    * @category Properties
+    */
+    distance: number;
+    /*
+    * get/set the azimuth angle (horizontal) in radians.
+    * Every 360 degrees turn is added to `.azimuthAngle` value, which is accumulative.
+    * @category Properties
+    */
+    azimuthAngle: number;
+    /*
+    * get/set the polar angle (vertical) in radians.
+    * @category Properties
+    */
+    polarAngle: number;
+    /*
+    * Whether camera position should be enclosed in the boundary or not.
+    * @category Properties
+    */
+    boundaryEnclosesCamera: boolean;
+    /*
+    * Set drag-start, touches and wheel enable area in the domElement.
+    * each values are between `0` and `1` inclusive, where `0` is left/top and `1` is right/bottom of the screen.
+    * e.g. `{ x: 0, y: 0, width: 1, height: 1 }` for entire area.
+    * @category Properties
+    */
+    interactiveArea:
+    | DOMRect
+    | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Adds the specified event listener.
+     * Applicable event types (which is `K`) are:
+     * | Event name          | Timing |
+     * | ------------------- | ------ |
+     * | `'controlstart'`    | When the user starts to control the camera via mouse / touches. ¹ |
+     * | `'control'`         | When the user controls the camera (dragging). |
+     * | `'controlend'`      | When the user ends to control the camera. ¹ |
+     * | `'transitionstart'` | When any kind of transition starts, either user control or using a method with `enableTransition = true` |
+     * | `'update'`          | When the camera position is updated. |
+     * | `'wake'`            | When the camera starts moving. |
+     * | `'rest'`            | When the camera movement is below `.restThreshold` ². |
+     * | `'sleep'`           | When the camera end moving. |
+     *
+     * 1. `mouseButtons.wheel` (Mouse wheel control) does not emit `'controlstart'` and `'controlend'`. `mouseButtons.wheel` uses scroll-event internally, and scroll-event happens intermittently. That means "start" and "end" cannot be detected.
+     * 2. Due to damping, `sleep` will usually fire a few seconds after the camera _appears_ to have stopped moving. If you want to do something (e.g. enable UI, perform another transition) at the point when the camera has stopped, you probably want the `rest` event. This can be fine tuned using the `.restThreshold` parameter. See the [Rest and Sleep Example](https://yomotsu.github.io/camera-controls/examples/rest-and-sleep.html).
+     *
+     * e.g.
+     * ```
+     * cameraControl.addEventListener( 'controlstart', myCallbackFunction );
+     * ```
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    addEventListener<K extends keyof CameraControlsEventMap>(
+    type: K,
+    listener: (event: CameraControlsEventMap[K]) => any,
+    ): void;
+    /**
+     * Removes the specified event listener
+     * e.g.
+     * ```
+     * cameraControl.addEventListener( 'controlstart', myCallbackFunction );
+     * ```
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    removeEventListener<K extends keyof CameraControlsEventMap>(
+    type: K,
+    listener: (event: CameraControlsEventMap[K]) => any,
+    ): void;
+    /**
+     * Rotate azimuthal angle(horizontal) and polar angle(vertical).
+     * Every value is added to the current value.
+     * @param azimuthAngle Azimuth rotate angle. In radian.
+     * @param polarAngle Polar rotate angle. In radian.
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    rotate(
+    azimuthAngle: number,
+    polarAngle: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Rotate azimuthal angle(horizontal) to the given angle and keep the same polar angle(vertical) target.
+     *
+     * e.g.
+     * ```
+     * cameraControls.rotateAzimuthTo( 30 * THREE.MathUtils.DEG2RAD, true );
+     * ```
+     * @param azimuthAngle Azimuth rotate angle. In radian.
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    rotateAzimuthTo(
+    azimuthAngle: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Rotate polar angle(vertical) to the given angle and keep the same azimuthal angle(horizontal) target.
+     *
+     * e.g.
+     * ```
+     * cameraControls.rotatePolarTo( 30 * THREE.MathUtils.DEG2RAD, true );
+     * ```
+     * @param polarAngle Polar rotate angle. In radian.
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    rotatePolarTo(polarAngle: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Rotate azimuthal angle(horizontal) and polar angle(vertical) to the given angle.
+     * Camera view will rotate over the orbit pivot absolutely:
+     *
+     * azimuthAngle
+     * ```
+     *       0º
+     *         \
+     * 90º -----+----- -90º
+     *           \
+     *           180º
+     * ```
+     * | direction | angle                  |
+     * | --------- | ---------------------- |
+     * | front     | 0º                     |
+     * | left      | 90º (`Math.PI / 2`)    |
+     * | right     | -90º (`- Math.PI / 2`) |
+     * | back      | 180º (`Math.PI`)       |
+     *
+     * polarAngle
+     * ```
+     *     180º
+     *      |
+     *      90º
+     *      |
+     *      0º
+     * ```
+     * | direction            | angle                  |
+     * | -------------------- | ---------------------- |
+     * | top/sky              | 180º (`Math.PI`)       |
+     * | horizontal from view | 90º (`Math.PI / 2`)    |
+     * | bottom/floor         | 0º                     |
+     *
+     * @param azimuthAngle Azimuth rotate angle to. In radian.
+     * @param polarAngle Polar rotate angle to. In radian.
+     * @param enableTransition  Whether to move smoothly or immediately
+     * @category Methods
+     */
+    rotateTo(
+    azimuthAngle: number,
+    polarAngle: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Dolly in/out camera position.
+     * @param distance Distance of dollyIn. Negative number for dollyOut.
+     * @param enableTransition Whether to move smoothly or immediately.
+     * @category Methods
+     */
+    dolly(distance: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Dolly in/out camera position to given distance.
+     * @param distance Distance of dolly.
+     * @param enableTransition Whether to move smoothly or immediately.
+     * @category Methods
+     */
+    dollyTo(distance: number, enableTransition?: boolean): Promise<void>;
+    protected _dollyToNoClamp(
+    distance: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Dolly in, but does not change the distance between the target and the camera, and moves the target position instead.
+     * Specify a negative value for dolly out.
+     * @param distance Distance of dolly.
+     * @param enableTransition Whether to move smoothly or immediately.
+     * @category Methods
+     */
+    dollyInFixed(distance: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Zoom in/out camera. The value is added to camera zoom.
+     * Limits set with `.minZoom` and `.maxZoom`
+     * @param zoomStep zoom scale
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    zoom(zoomStep: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Zoom in/out camera to given scale. The value overwrites camera zoom.
+     * Limits set with .minZoom and .maxZoom
+     * @param zoom
+     * @param enableTransition
+     * @category Methods
+     */
+    zoomTo(zoom: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * @deprecated `pan()` has been renamed to `truck()`
+     * @category Methods
+     */
+    pan(x: number, y: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Truck and pedestal camera using current azimuthal angle
+     * @param x Horizontal translate amount
+     * @param y Vertical translate amount
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    truck(x: number, y: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Move forward / backward.
+     * @param distance Amount to move forward / backward. Negative value to move backward
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    forward(distance: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Move up / down.
+     * @param height Amount to move up / down. Negative value to move down
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    elevate(height: number, enableTransition?: boolean): Promise<void>;
+    /**
+     * Move target position to given point.
+     * @param x x coord to move center position
+     * @param y y coord to move center position
+     * @param z z coord to move center position
+     * @param enableTransition Whether to move smoothly or immediately
+     * @category Methods
+     */
+    moveTo(
+    x: number,
+    y: number,
+    z: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Look in the given point direction.
+     * @param x point x.
+     * @param y point y.
+     * @param z point z.
+     * @param enableTransition Whether to move smoothly or immediately.
+     * @returns Transition end promise
+     * @category Methods
+     */
+    lookInDirectionOf(
+    x: number,
+    y: number,
+    z: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Fit the viewport to the box or the bounding box of the object, using the nearest axis. paddings are in unit.
+     * set `cover: true` to fill enter screen.
+     * e.g.
+     * ```
+     * cameraControls.fitToBox( myMesh );
+     * ```
+     * @param box3OrObject Axis aligned bounding box to fit the view.
+     * @param enableTransition Whether to move smoothly or immediately.
+     * @param options | `<object>` { cover: boolean, paddingTop: number, paddingLeft: number, paddingBottom: number, paddingRight: number }
+     * @returns Transition end promise
+     * @category Methods
+     */
+    fitToBox(
+    box3OrObject: _THREE.Box3 | _THREE.Object3D,
+    enableTransition: boolean,
+        {
+        cover,
+        paddingLeft,
+        paddingRight,
+        paddingBottom,
+        paddingTop,
+    }?: Partial<FitToOptions>,
+    ): Promise<void[]>;
+    /**
+     * Fit the viewport to the sphere or the bounding sphere of the object.
+     * @param sphereOrMesh
+     * @param enableTransition
+     * @category Methods
+     */
+    fitToSphere(
+    sphereOrMesh: _THREE.Sphere | _THREE.Object3D,
+    enableTransition: boolean,
+    ): Promise<void[]>;
+    /**
+     * Look at the `target` from the `position`.
+     * @param positionX
+     * @param positionY
+     * @param positionZ
+     * @param targetX
+     * @param targetY
+     * @param targetZ
+     * @param enableTransition
+     * @category Methods
+     */
+    setLookAt(
+    positionX: number,
+    positionY: number,
+    positionZ: number,
+    targetX: number,
+    targetY: number,
+    targetZ: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Similar to setLookAt, but it interpolates between two states.
+     * @param positionAX
+     * @param positionAY
+     * @param positionAZ
+     * @param targetAX
+     * @param targetAY
+     * @param targetAZ
+     * @param positionBX
+     * @param positionBY
+     * @param positionBZ
+     * @param targetBX
+     * @param targetBY
+     * @param targetBZ
+     * @param t
+     * @param enableTransition
+     * @category Methods
+     */
+    lerpLookAt(
+    positionAX: number,
+    positionAY: number,
+    positionAZ: number,
+    targetAX: number,
+    targetAY: number,
+    targetAZ: number,
+    positionBX: number,
+    positionBY: number,
+    positionBZ: number,
+    targetBX: number,
+    targetBY: number,
+    targetBZ: number,
+    t: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Set angle and distance by given position.
+     * An alias of `setLookAt()`, without target change. Thus keep gazing at the current target
+     * @param positionX
+     * @param positionY
+     * @param positionZ
+     * @param enableTransition
+     * @category Methods
+     */
+    setPosition(
+    positionX: number,
+    positionY: number,
+    positionZ: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Set the target position where gaze at.
+     * An alias of `setLookAt()`, without position change. Thus keep the same position.
+     * @param targetX
+     * @param targetY
+     * @param targetZ
+     * @param enableTransition
+     * @category Methods
+     */
+    setTarget(
+    targetX: number,
+    targetY: number,
+    targetZ: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Set focal offset using the screen parallel coordinates. z doesn't affect in Orthographic as with Dolly.
+     * @param x
+     * @param y
+     * @param z
+     * @param enableTransition
+     * @category Methods
+     */
+    setFocalOffset(
+    x: number,
+    y: number,
+    z: number,
+    enableTransition?: boolean,
+    ): Promise<void>;
+    /**
+     * Set orbit point without moving the camera.
+     * SHOULD NOT RUN DURING ANIMATIONS. `setOrbitPoint()` will immediately fix the positions.
+     * @param targetX
+     * @param targetY
+     * @param targetZ
+     * @category Methods
+     */
+    setOrbitPoint(targetX: number, targetY: number, targetZ: number): void;
+    /**
+     * Set the boundary box that encloses the target of the camera. box3 is in THREE.Box3
+     * @param box3
+     * @category Methods
+     */
+    setBoundary(box3?: _THREE.Box3): void;
+    /** Keep the camera and near plane above a surface, with a minimum view elevation (default 5 degrees). */
+    setBoundaryPlane(plane?: _THREE.Plane, minElevationAngle?: number): void;
+    /**
+     * Set (or unset) the current viewport.
+     * Set this when you want to use renderer viewport and .dollyToCursor feature at the same time.
+     * @param viewportOrX
+     * @param y
+     * @param width
+     * @param height
+     * @category Methods
+     */
+    setViewport(
+    viewportOrX: _THREE.Vector4 | number | null,
+    y: number,
+    width: number,
+    height: number,
+    ): void;
+    /**
+     * Calculate the distance to fit the box.
+     * @param width box width
+     * @param height box height
+     * @param depth box depth
+     * @returns distance
+     * @category Methods
+     */
+    getDistanceToFitBox(
+    width: number,
+    height: number,
+    depth: number,
+    cover?: boolean,
+    ): number;
+    /**
+     * Calculate the distance to fit the sphere.
+     * @param radius sphere radius
+     * @returns distance
+     * @category Methods
+     */
+    getDistanceToFitSphere(radius: number): number;
+    /**
+     * Returns the orbit center position, where the camera looking at.
+     * @param out The receiving Vector3 instance to copy the result
+     * @param receiveEndValue Whether receive the transition end coords or current. default is `true`
+     * @category Methods
+     */
+    getTarget(out: _THREE.Vector3, receiveEndValue?: boolean): _THREE.Vector3;
+    /**
+     * Returns the camera position.
+     * @param out The receiving Vector3 instance to copy the result
+     * @param receiveEndValue Whether receive the transition end coords or current. default is `true`
+     * @category Methods
+     */
+    getPosition(out: _THREE.Vector3, receiveEndValue?: boolean): _THREE.Vector3;
+    /**
+     * Returns the spherical coordinates of the orbit.
+     * @param out The receiving Spherical instance to copy the result
+     * @param receiveEndValue Whether receive the transition end coords or current. default is `true`
+     * @category Methods
+     */
+    getSpherical(
+    out: _THREE.Spherical,
+    receiveEndValue?: boolean,
+    ): _THREE.Spherical;
+    /**
+     * Returns the focal offset, which is how much the camera appears to be translated in screen parallel coordinates.
+     * @param out The receiving Vector3 instance to copy the result
+     * @param receiveEndValue Whether receive the transition end coords or current. default is `true`
+     * @category Methods
+     */
+    getFocalOffset(
+    out: _THREE.Vector3,
+    receiveEndValue?: boolean,
+    ): _THREE.Vector3;
+    /**
+     * Normalize camera azimuth angle rotation between 0 and 360 degrees.
+     * @category Methods
+     */
+    normalizeRotations(): void;
+    /**
+     * stop all transitions.
+     */
+    stop(): void;
+    /**
+     * Reset all rotation and position to defaults.
+     * @param enableTransition
+     * @category Methods
+     */
+    reset(enableTransition?: boolean): Promise<void[]>;
+    /**
+     * Set current camera position as the default position.
+     * @category Methods
+     */
+    saveState(): void;
+    /**
+     * Sync camera-up direction.
+     * When camera-up vector is changed, `.updateCameraUp()` must be called.
+     * @category Methods
+     */
+    updateCameraUp(): void;
+    /**
+     * Apply current camera-up direction to the camera.
+     * The orbit system will be re-initialized with the current position.
+     * @category Methods
+     */
+    applyCameraUp(): void;
+    /**
+     * Update camera position and directions.
+     * This should be called in your tick loop every time, and returns true if re-rendering is needed.
+     * @param delta
+     * @returns updated
+     * @category Methods
+     */
+    update(delta: number): boolean;
+    /**
+     * Get all state in JSON string
+     * @category Methods
+     */
+    toJSON(): string;
+    /**
+     * Reproduce the control state with JSON. enableTransition is where anim or not in a boolean.
+     * @param json
+     * @param enableTransition
+     * @category Methods
+     */
+    fromJSON(json: string, enableTransition?: boolean): void;
+    /**
+     * Attach all internal event handlers to enable drag control.
+     * @category Methods
+     */
+    connect(domElement: HTMLElement): void;
+    /**
+     * Detach all internal event handlers to disable drag control.
+     */
+    disconnect(): void;
+    /**
+     * Dispose the cameraControls instance itself, remove all eventListeners.
+     * @category Methods
+     */
+    dispose(): void;
+    protected _getTargetDirection(out: _THREE.Vector3): _THREE.Vector3;
+    protected _getCameraDirection(out: _THREE.Vector3): _THREE.Vector3;
+    protected _findPointerById(pointerId: number): PointerInput | undefined;
+    protected _findPointerByMouseButton(
+    mouseButton: MOUSE_BUTTON,
+    ): PointerInput | undefined;
+    protected _disposePointer(pointer: PointerInput): void;
+    protected _encloseToBoundary(
+    position: _THREE.Vector3,
+    offset: _THREE.Vector3,
+    friction: number,
+    ): _THREE.Vector3;
+    protected _updateNearPlaneCorners(): void;
+    protected _truckInternal: (
+    deltaX: number,
+    deltaY: number,
+    dragToOffset: boolean,
+    screenSpacePanning: boolean,
+    ) => void;
+    protected _rotateInternal: (deltaX: number, deltaY: number) => void;
+    protected _dollyInternal: (delta: number, x: number, y: number) => void;
+    protected _zoomInternal: (delta: number, x: number, y: number) => void;
+    protected _collisionTest(): number;
+    /**
+     * Get its client rect and package into given `DOMRect` .
+     */
+    protected _getClientRect(target: DOMRect): DOMRect | undefined;
+    protected _createOnRestPromise(resolveImmediately: boolean): Promise<void>;
+    protected _addAllEventListeners(_domElement: HTMLElement): void;
+    protected _removeAllEventListeners(): void;
+    /*
+    * backward compatible
+    * @deprecated use smoothTime (in seconds) instead
+    * @category Properties
+
+
+    * backward compatible
+    * @deprecated use smoothTime (in seconds) instead
+    * @category Properties
+    */
+    dampingFactor: number;
+    /*
+    * backward compatible
+    * @deprecated use draggingSmoothTime (in seconds) instead
+    * @category Properties
+
+
+    * backward compatible
+    * @deprecated use draggingSmoothTime (in seconds) instead
+    * @category Properties
+    */
+    draggingDampingFactor: number;
+    static createBoundingSphere(
+    object3d: _THREE.Object3D,
+    out?: _THREE.Sphere,
+    ): _THREE.Sphere;
+}
+
+declare interface CameraControlsEventMap {
+    update: {
+        type: 'update';
+    };
+    wake: {
+        type: 'wake';
+    };
+    rest: {
+        type: 'rest';
+    };
+    sleep: {
+        type: 'sleep';
+    };
+    transitionstart: {
+        type: 'transitionstart';
+    };
+    controlstart: {
+        type: 'controlstart';
+    };
+    control: {
+        type: 'control';
+    };
+    controlend: {
+        type: 'controlend';
+    };
+}
+
+declare class CameraPages extends OrigonPages<PerspectiveCamera_2> {
+    get camera(): PerspectiveCamera_2;
+    width: number;
+    height: number;
+    private _cachedMatrixWorld;
+    private _cachedMatrixWorldInverse;
+    private externallySyncedCameras;
+    private ownedCameras;
+    constructor(options: Options_3);
+    addPerspectiveCamera(cameraParams?: {
+        fov: number;
+        aspect?: number;
+        near: number;
+        far: number;
+        up: Vector3;
+    }, index?: number): PerspectiveCamera_2;
+    setPageActive(index: number): void;
+    setSize(width: number, height: number): void;
+    setAspect(aspect: number, c?: PerspectiveCamera_2): void;
+    cloneCamera(index?: number): PerspectiveCamera_2;
+    createCameraClone(): PerspectiveCamera_2;
+    removePage(index: number, callback?: (camera: PerspectiveCamera_2) => void): void;
+    sync(cameraInput: PerspectiveCamera_2 | {
+        fov: number;
+        viewMatrix: any;
+        inverseViewMatrix: any;
+        type?: string;
+    }): void;
+    update(delta: number, elapsed: number): void;
+}
+
+declare interface CameraParams {
+    fov: number;
+    near: number;
+    far: number;
+    up: Vector3;
+}
+
 declare class Circle extends MeshObject {
     objectType: string;
     create(): void;
@@ -416,13 +1851,13 @@ declare interface CityOptions {
 
 declare class CityPlane extends MeshObject {
     objectType: string;
-    options: Options_10;
-    constructor(options: Options_10);
-    plane: THREE.PlaneGeometry;
+    options: Options_23;
+    constructor(options: Options_23);
+    plane: _THREE.BufferGeometry;
     water?: Water;
     create(): Promise<void>;
     rebuildFromScene(): void;
-    addWater(normalMaps: [THREE.Texture, THREE.Texture]): void;
+    addWater(normalMaps: [_THREE.Texture, _THREE.Texture]): void;
     dispose(): void;
 }
 
@@ -442,11 +1877,239 @@ export declare function collectSceneResourceReuse(target: any, candidates: reado
 /** Configuration and alias values are additional conservative resource roots. */
 export declare function collectStructureResources(graph: Record<string, any>, roots: readonly Record<string, any>[], additionalReferences?: readonly unknown[]): StructureResources;
 
+/**
+ * 标签碰撞检测管理器
+ * 参考 Mapbox symbol-placement 实现
+ *
+ * 使用方式：
+ * ```ts
+ * const manager = new CollisionManager({ padding: 4 });
+ * manager.add(node, { priority: 10 });
+ * manager.update(camera); // 在渲染循环中调用
+ * ```
+ */
+declare class CollisionManager {
+    private labels;
+    private options;
+    private lastUpdateTime;
+    private camera?;
+    private animationFrameId?;
+    private isUpdating;
+    private dirty;
+    private disposed;
+    private viewportWidth?;
+    private viewportHeight?;
+    constructor(options?: CollisionManagerOptions);
+    /**
+     * 添加标签到碰撞检测系统
+     * @param node Node 实例
+     */
+    add(node: NodeObject, options?: {
+        priority?: number;
+    }): void;
+    /**
+     * 移除标签
+     */
+    remove(node: NodeObject): void;
+    /**
+     * 更新标签优先级
+     */
+    setPriority(node: NodeObject, priority: number): void;
+    /**
+     * 批量添加标签
+     */
+    addBatch(nodes: NodeObject[], priorityFn?: (node: NodeObject, index: number) => number): void;
+    /**
+     * 启用/禁用碰撞检测
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 更新碰撞检测（在渲染循环中调用）
+     */
+    update(camera: Camera_3): void;
+    /**
+     * 强制立即更新
+     */
+    forceUpdate(): void;
+    private performCollisionDetection;
+    private sameRect;
+    /**
+     * 检测矩形是否与已占用区域碰撞
+     */
+    private checkCollision;
+    /**
+     * 检测两个矩形是否相交（包含 padding）
+     */
+    private rectsIntersect;
+    /**
+     * 设置节点可见性（操作子元素，带淡入淡出）
+     */
+    private setNodeVisibility;
+    /**
+     * 获取当前可见的标签数量
+     */
+    getVisibleCount(): number;
+    /**
+     * 获取所有标签数量
+     */
+    getTotalCount(): number;
+    /**
+     * 调试执行碰撞检测（带详细日志）
+     */
+    debugRun(): void;
+    /**
+     * 清空所有标签
+     */
+    clear(): void;
+    private cancelUpdate;
+    /**
+     * 销毁管理器
+     */
+    dispose(): void;
+}
+
+declare interface CollisionManagerOptions {
+    /** 标签之间的最小间距（像素） */
+    padding?: number;
+    /** 是否启用碰撞检测 */
+    enabled?: boolean;
+    /** 更新节流时间（毫秒） */
+    throttleTime?: number;
+    /** 视口边距，标签超出视口多少像素后隐藏 */
+    viewportMargin?: number;
+    /** 稳定性加成，当前显示的标签会获得额外优先级，避免频繁切换 */
+    stabilityBonus?: number;
+    /** 淡入淡出动画时间（毫秒），0 表示禁用 */
+    fadeTime?: number;
+}
+
+declare const ColorSpace: {
+    readonly linearSRGB: "srgb-linear";
+    readonly sRGB: "srgb";
+    readonly none: "";
+};
+
+/** WebGPU render pipeline. Compatibility controls retain the saved scene schema. */
+declare class Composer {
+    renderer: WebGPURenderer;
+    scene: Scene_2;
+    camera: Camera_2;
+    finalComposer: RenderPipeline;
+    renderPass: {
+        scene: Scene_2;
+        camera: Camera_2;
+    };
+    bloomComposer?: RenderTarget;
+    bloomComposerActive: boolean;
+    bloomPass?: Omit<BloomParams, 'bloomAlphaType'> & {
+        enabled: boolean;
+    };
+    ssaoPass?: SSAOParams & {
+        enabled: boolean;
+        output: number;
+    };
+    mixPass?: {
+        enabled: boolean;
+        uniforms: {
+            bloomAlphaType: {
+                value: 0 | 0.5 | 1;
+            };
+        };
+    };
+    outputPass: {
+        outputTarget?: RenderTarget;
+        uniforms: {
+            premultiplieAlpha: {
+                value: number;
+            };
+        };
+    };
+    bloomSelection: Set<BaseObject< Object3D<Object3DEventMap>>>;
+    bloomLayer: Layers;
+    active: boolean;
+    options: Options_2;
+    private readonly target;
+    private overlayTarget?;
+    private outputPipeline?;
+    private readonly bloomRenderer;
+    private bloomNode?;
+    private aoNode?;
+    private readonly views;
+    private readonly bloomEnabled;
+    private readonly aoEnabled;
+    private readonly alphaMode;
+    private readonly premultiply;
+    private width;
+    private height;
+    private pixelRatio;
+    private rendering;
+    private disposed;
+    private readonly presentation;
+    private readonly gtaoLighting;
+    private readonly gtaoViews;
+    private readonly onCameraChange;
+    private readonly onSceneChange;
+    constructor(options: Options_2);
+    private createDepthTexture;
+    private resizeTargets;
+    private rebuild;
+    private activateView;
+    changeCamera(camera: Camera_2): void;
+    changeScene(scene: Scene_2): void;
+    addOutputPass(): void;
+    setPremultiplieAlpha(value: boolean): void;
+    addSSAOPass(params: SSAOParams): void;
+    addBloomPass(params: BloomParams): void;
+    checkBloomComposerActive(): void;
+    enable(): void;
+    disable(): void;
+    setSize(width: number, height: number): void;
+    setPixelRatio(ratio: number): void;
+    getSize(): Vector2;
+    finalComposerRender(preserveOutput?: boolean): void;
+    private renderFinal;
+    pipViewportState: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    private pipCamera?;
+    setPipView(camera: Camera_2 | undefined, viewport: Composer['pipViewportState']): void;
+    render(overlays?: () => void): void;
+    private renderPresentation;
+    private renderViews;
+    dispose(): void;
+}
+
+declare interface ComposerParams {
+    multisampling: number;
+    premultiplieAlpha: boolean;
+}
+
+declare interface ConicLineMessage {
+    projection?: 'cesium' | 'sphere';
+    useGroups?: 0 | 1 | 2;
+    useRTC?: boolean;
+}
+
+declare interface ConicPolygonMessage {
+    useGroups?: 0 | 1 | 2;
+    hasTop?: boolean;
+    topFirst?: boolean;
+    hasBottom?: boolean;
+    hasSide?: boolean;
+    curvatureResolution?: number;
+    projection?: 'cesium' | 'sphere';
+    bbox?: number[];
+    splitPolygons?: number;
+}
+
 declare class ContinentsBg extends GroupObject {
     objectType: string;
-    options: Options_5;
+    options: Options_18;
     mapArr: PlaneMap_2[];
-    constructor(options: Options_5);
+    constructor(options: Options_18);
     create(): Promise<void>;
     getLocationPosition(location: [number, number], name?: string, height?: number): [number, number, number] | undefined;
     private calculatePosition;
@@ -455,6 +2118,39 @@ declare class ContinentsBg extends GroupObject {
     dispose(): void;
 }
 
+declare class ControlsPages extends OrigonPages<CameraControls> {
+    options: Options_6;
+    private viewport?;
+    private controllerViewports;
+    get cameraControls(): CameraControls;
+    autoRotateSpeed: number;
+    interactionEnabled: boolean;
+    constructor(options: Options_6);
+    addCameraControls(camera: PerspectiveCamera_2 | OrthographicCamera, index?: number): CameraControls;
+    /** A detached controller for auxiliary views; it is not owned by a scene page. */
+    createCameraControls(camera: PerspectiveCamera_2 | OrthographicCamera, acceptsInput?: (event: MouseEvent) => boolean): CameraControls;
+    setViewport(viewport: ControlsViewport): void;
+    applyViewport(controls: CameraControls, viewport: ControlsViewport): void;
+    setPageActive(index: number): void;
+    removePage(index: number): void;
+    enable(): void;
+    disable(): void;
+    update(delta: number, elapsed: number): void;
+}
+
+declare interface ControlsParams {
+    domElement: HTMLElement;
+}
+
+declare interface ControlsViewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fullWidth: number;
+    fullHeight: number;
+}
+
 /** Copy only the copied branches; source nodes and existing resource rows keep
  * their identity, including when several copies share one procedural geometry. */
 export declare function copyNativeGeometries(document: VisSceneDocument, sceneId: string, pairs: readonly {
@@ -504,8 +2200,57 @@ export declare function createSceneResourceReuseSession(candidates?: readonly Sc
     }) => Required<ReusableObjectResources>;
 };
 
-/** Reuse renderer indexes while retaining material asset aliases and prefab dependencies. */
-export declare function createStructureResourceCollector(graph: Record<string, any>): (roots: readonly Record<string, any>[], additionalReferences?: readonly unknown[]) => StructureResources;
+/** Reuse renderer indexes while retaining material asset aliases and prefab dependencies. */
+export declare function createStructureResourceCollector(graph: Record<string, any>): (roots: readonly Record<string, any>[], additionalReferences?: readonly unknown[]) => StructureResources;
+
+declare type CSSObject = CSS2DObject | CSS3DObject | CSS3DSprite;
+
+declare class CSSRendererController {
+    css2Drenderer?: CSS2DRenderer;
+    css3Drenderer?: CSS3DRenderer;
+    container: HTMLElement;
+    /** 标签碰撞检测管理器 */
+    collisionManager: CollisionManager;
+    private viewport?;
+    constructor(container: HTMLElement, options?: CSSRendererParams);
+    addRenderer(type: 'css2d' | 'css3d', options?: CSSRendererParams): void;
+    setSize(width: number, height: number): void;
+    setViewport(viewport: CSSRendererViewport): void;
+    private applyViewport;
+    render(scene: Scene, camera: PerspectiveCamera_2): void;
+    dispose(): void;
+}
+
+declare interface CSSRendererParams {
+    zIndex?: string;
+    container?: HTMLElement;
+    /** 碰撞检测配置 */
+    collision?: {
+        /** 是否启用碰撞检测，默认 true */
+        enabled?: boolean;
+        /** 标签之间的最小间距（像素），默认 4 */
+        padding?: number;
+        /** 更新节流时间（毫秒），默认 16 */
+        throttleTime?: number;
+        /** 视口边距，默认 50 */
+        viewportMargin?: number;
+    };
+}
+
+declare interface CSSRendererViewport {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+declare type DeepRequired<T> = T extends Function | HTMLElement ? T : T extends object ? {
+    [P in keyof T]-?: DeepRequired<T[P]>;
+} : T;
+
+declare type DeepRequiredOptions = DeepRequired<Options>;
+
+declare const _default: (attributes: any) => BufferGeometry< NormalBufferAttributes, BufferGeometryEventMap>;
 
 declare class DirectionalLight extends DirectionalLightObject {
     constructor(...options: ConstructorParameters<typeof DirectionalLightObject>);
@@ -513,6 +2258,31 @@ declare class DirectionalLight extends DirectionalLightObject {
     render(): void;
 }
 
+declare class DirectionalLightObject extends BaseObject<DirectionalLight_2> {
+    objectType: string;
+    constructor(lightOrColor?: DirectionalLight_2 | string | number, intensity?: number);
+    render(): void;
+    dispose(): void;
+}
+
+declare interface DispatcherEvent {
+    type: string;
+    [key: string]: any;
+}
+
+declare const DOLLY_DIRECTION: {
+    readonly NONE: 0;
+    readonly IN: 1;
+    readonly OUT: -1;
+};
+
+declare type DOLLY_DIRECTION =
+(typeof DOLLY_DIRECTION)[keyof typeof DOLLY_DIRECTION];
+
+declare interface DrawOptions {
+    target?: BaseObject | string | null;
+}
+
 export declare function duplicateMaterialAssetDocument(document: VisSceneDocument, id: string, newId: string, mode: 'asset' | 'object' | 'scene', sceneId: string, objectId?: string, slot?: number): VisSceneDocument;
 
 /** One-click copy and apply; preserve the source's user-visible scope. */
@@ -564,7 +2334,7 @@ declare class Earth_3 extends Base_3 {
         Plane: Plane;
         PlaneShadow: PlaneShadow;
         Sphere: Sphere;
-        Sprite: Sprite;
+        Sprite: Sprite_2;
         Box: Box;
         Circle: Circle;
         Tube: TubeObject;
@@ -612,8 +2382,8 @@ declare class Earth_3 extends Base_3 {
 
 declare class Earth_4 extends Sphere {
     objectType: string;
-    options: Required<Options_2>;
-    constructor(options: Options_2);
+    options: Required<Options_15>;
+    constructor(options: Options_15);
     create(): void;
     rebuildFromScene(): void;
 }
@@ -644,7 +2414,7 @@ export declare const editorEarthObjects: {
     Plane: Plane;
     PlaneShadow: PlaneShadow;
     Sphere: Sphere;
-    Sprite: Sprite;
+    Sprite: Sprite_2;
     Box: Box;
     Circle: Circle;
     Tube: TubeObject;
@@ -668,7 +2438,7 @@ export declare const editorObjects: {
     Plane: typeof Plane;
     PlaneShadow: typeof PlaneShadow;
     Sphere: typeof Sphere;
-    Sprite: typeof Sprite;
+    Sprite: typeof Sprite_2;
     Box: typeof Box;
     Circle: typeof Circle;
     Tube: typeof TubeObject;
@@ -698,6 +2468,43 @@ declare class Event_2 {
     dispose(): void;
 }
 
+declare class EventDispatcher {
+    private _listeners;
+    /**
+     * Adds the specified event listener.
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    addEventListener(type: string, listener: Listener_2): void;
+    /**
+     * Presence of the specified event listener.
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    hasEventListener(type: string, listener: Listener_2): boolean;
+    /**
+     * Removes the specified event listener
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    removeEventListener(type: string, listener: Listener_2): void;
+    /**
+     * Removes all event listeners
+     * @param type event name
+     * @category Methods
+     */
+    removeAllEventListeners(type?: string): void;
+    /**
+     * Fire an event type.
+     * @param event DispatcherEvent
+     * @category Methods
+     */
+    dispatchEvent(event: DispatcherEvent): void;
+}
+
 /** Internal: Consume an exclusively owned import copy; pooled slots still get independent payloads. */
 export declare function expandOwnedSceneDocumentResources<T extends VisSceneDocument>(expanded: T): T;
 
@@ -707,6 +2514,15 @@ export declare function expandSceneDocumentResources<T extends VisSceneDocument>
 /** Expand renderer pools, including snapshots retained as prefab baselines. */
 export declare function expandStructureSnapshot<T extends Record<string, any>>(input: T): T;
 
+declare interface ExportBaseObjectOptions {
+    /** Serialize a node's own state and resources without visiting descendants. */
+    recursive?: boolean;
+    checkTextures?: boolean;
+    includeHiddenChildren?: boolean;
+    includeUnusedUnlockedMaterials?: boolean;
+    includeAnalysisMeta?: boolean;
+}
+
 /** Extract only this material's dependencies, without mutating the scene snapshot. */
 export declare function extractMaterialDefinition(scene: SceneViewportDocument, materialUuid: string): Record<string, any>;
 
@@ -714,8 +2530,71 @@ export declare function extractMaterialDefinition(scene: SceneViewportDocument,
  * dependencies of the live object. Baselines remain in the copied metadata. */
 export declare function extractObjectResourceGraph(graph: any, object: any): any;
 
+declare interface ExtrudePolygonMessage {
+    bevelRatio?: number;
+    bbox?: number[];
+    projection?: ProjectionOptions;
+    useGroups?: 0 | 1 | 2;
+    hasTop?: boolean;
+    hasBottom?: boolean;
+    hasSide?: boolean;
+    splitPolygons?: number;
+    topSegments?: number;
+}
+
+declare class ExtrudePolygonObject extends MeshObject {
+    objectType: string;
+    options: ExtrudePolygonObjectOptions;
+    constructor(options: ExtrudePolygonObjectOptions);
+    create(): Promise<void>;
+    private createWithWorker;
+    private createLocal;
+}
+
+declare interface ExtrudePolygonObjectOptions {
+    material?: Material | Material[];
+    geometry?: BufferGeometry;
+    coordinatesArr?: number[][][];
+    metaArray?: number[][];
+    globalMeta?: number[];
+    useWorker?: boolean;
+    useGroups?: 0 | 1 | 2;
+    hasTop?: boolean;
+    hasBottom?: boolean;
+    hasSide?: boolean;
+    bbox?: number[];
+    projection?: ProjectionOptions | 'cesium' | 'sphere';
+    splitPolygons?: number;
+    topSegments?: number;
+    bevelRatio?: number;
+    cacheKey?: string;
+    userData?: Record<string, any>;
+    curvatureResolution?: number;
+    topFirst?: boolean;
+    useFloat64Array?: boolean;
+    onCacheMiss?: (options: Partial<ExtrudePolygonObjectOptions>) => Partial<ExtrudePolygonObjectOptions> | Promise<Partial<ExtrudePolygonObjectOptions>>;
+}
+
 export declare const findAdcodeInfo: (adcode: number) => AdcodeInfo | undefined;
 
+declare interface FitToOptions {
+    cover: boolean;
+    paddingLeft: number;
+    paddingRight: number;
+    paddingBottom: number;
+    paddingTop: number;
+}
+
+declare interface GeoGeometryOptions extends Options_13 {
+    coordinatesArr: number[][][];
+    metaArray?: number[][];
+    globalMeta?: number[];
+    cacheKey?: string;
+    userData?: Record<string, any>;
+    useFloat64Array?: boolean;
+    cb?: (geometry: BufferGeometry) => void;
+}
+
 declare type GeoJSON_2 = FeatureCollection<Polygon | MultiPolygon>;
 export { GeoJSON_2 as GeoJSON }
 
@@ -723,6 +2602,13 @@ declare type GeoJSON_3 = FeatureCollection<Polygon | MultiPolygon>;
 
 declare type GeoJSON_4 = FeatureCollection<Polygon | MultiPolygon>;
 
+declare interface GeometryDefinition {
+    geometry: Record<string, any>;
+    shapes?: Record<string, any>[];
+}
+
+declare function geoWinkel3(): GeoProjection;
+
 /** Saved configuration dependencies protect definitions, without representing live usage. */
 export declare function getMaterialDependencies(document: Pick<VisSceneDocument, 'scenes'>, assetId?: string): MaterialUsage[];
 
@@ -736,6 +2622,12 @@ export declare function getSceneDocument(document: VisSceneDocument, sceneId?: s
     resolveResources?: boolean;
 }): SceneViewportDocument;
 
+declare class GroupObject extends BaseObject<Group> {
+    objectType: string;
+    constructor(group?: Group< Object3DEventMap>);
+    render(): void;
+}
+
 /** An identity group shell keeps selected sibling objects and their transforms untouched. */
 export declare function groupObjectsDocument(before: VisSceneDocument, sceneId: string, ids: readonly string[], options?: GroupObjectsDocumentOptions): {
     document: VisSceneDocument;
@@ -749,9 +2641,40 @@ export declare interface GroupObjectsDocumentOptions {
     userData?: Record<string, any>;
 }
 
+declare class HelperController {
+    helpers: Record<string, any>;
+    viewHelper?: ViewHelper;
+    options: Options_8;
+    private viewHelperPointerDown?;
+    private viewHelperCamera?;
+    private viewHelperEnabled;
+    private sceneHelper?;
+    private sceneHelperKey?;
+    private activeScene?;
+    private selectionBounds;
+    constructor(options: Options_8);
+    add(object: any): void;
+    addViewHelper(camera?: PerspectiveCamera_2): void;
+    bindActiveView(camera: CameraPages['camera'] | undefined, target?: Vector3_2): void;
+    private bindSceneHelper;
+    addSceneHelper(): void;
+    remove(object: any): void;
+    removeAll(): void;
+    removeAllExcludeScene(): void;
+    update(delta: number, controlsController: ControlsPages, cameraTarget: Vector3_2): void;
+    renderViewHelper(renderer: WebGPURenderer): void;
+    private removeViewHelper;
+    dispose(): void;
+}
+
 declare class HemisphereLight extends HemisphereLightObject {
 }
 
+declare class HemisphereLightObject extends BaseObject<HemisphereLight_2> {
+    objectType: string;
+    constructor(skyColorOrLight?: HemisphereLight_2 | string | number, groundColor?: string | number, intensity?: number);
+}
+
 declare type IdentityPath = (string | number)[];
 
 export declare function indexedSceneObject(root: any, uuid: string): {
@@ -759,6 +2682,15 @@ export declare function indexedSceneObject(root: any, uuid: string): {
     path: readonly number[];
 } | undefined;
 
+declare interface InfoData {
+    render: {
+        timestamp: number;
+    };
+    compute: {
+        timestamp: number;
+    };
+}
+
 /** Property-only immutable copies retain exactly the same UUID paths. */
 export declare function inheritSceneObjectIndex(previous: any, next: any): void;
 
@@ -788,6 +2720,103 @@ export declare function isSceneManifest(value: unknown): value is VisSceneManife
 
 export declare const isSceneObjectPropertyField: (field: string) => boolean;
 
+declare const KNOWN_ASSET_TYPES: {
+    readonly images: readonly ["png", "jpg", "jpeg", "ico", "webp", "avif"];
+    readonly media: readonly ["mp4", "webm", "ogg"];
+    readonly gltf: readonly ["gltf", "glb"];
+    readonly json: readonly ["json", "geojson"];
+    readonly gzipJson: readonly ["json.gzip", "json.gz"];
+    readonly exr: readonly ["exr"];
+    readonly lottie: readonly ["lottie.json"];
+};
+
+declare type Lead = Lead_2;
+
+declare class Lead_2 extends Pick_2 {
+    objMap: Map<Object3D< Object3DEventMap>, BaseObject<Object3D< Object3DEventMap>>>;
+    objects: Map<string, BaseObject<Object3D< Object3DEventMap>>>;
+    /** Compatibility name for the same UUID index, never a second identity map. */
+    get objectsByUuid(): Map<string, BaseObject<Object3D< Object3DEventMap>>>;
+    private registeredUuids;
+    private disposing;
+    objectsPm: Map<BaseObject<Object3D< Object3DEventMap>>, Promise<void>>;
+    scene: BaseObject;
+    sceneResources: SceneResources_2;
+    get objectsPromise(): MapIterator<Promise<void>>;
+    constructor(pencil: Pencil, ops: {
+        scene: Scene;
+        sceneResources: SceneResources_2;
+    });
+    /**
+     * 核心注册逻辑：统一处理对象到 Lead 系统的注册
+     * 包含：依赖注入、Key 生成、Map 存储。
+     * 已注册对象可再次调用，以刷新替换骨骼后的资源引用。
+     */
+    register(baseObject: BaseObject): BaseObject<Object3D< Object3DEventMap>>;
+    /** Update identity and its only index atomically; never rename children. */
+    setObjectUuid(baseObject: BaseObject, uuid: string): void;
+    /**
+     * Internal: Exchange staged runtime identities without migrating authored
+     * references. A structure transaction owns both trees and their rollback;
+     * user-requested identity changes must continue to use setObjectUuid().
+     */
+    rekeyObjectsForTransaction(assignments: readonly {
+        object: BaseObject;
+        uuid: string;
+    }[]): void;
+    /**
+     * 内部初始化核心对象 (Scene, Camera 等)
+     * 模拟 add 的部分逻辑，但不走完整的 spawn 流程
+     */
+    private _initCoreObject;
+    draw<C extends new (...args: any[]) => BaseObject>(ClassRef: C, ...args: ConstructorParameters<C>): Promise<InstanceType<C>>;
+    draw<C extends new (...args: any[]) => BaseObject>(options: DrawOptions, ClassRef: C, ...args: ConstructorParameters<C>): Promise<InstanceType<C>>;
+    /**
+     * 将原生 Object3D 包装为 BaseObject (Wrapper Pattern)
+     * 如果已存在包装器，则返回现有实例
+     */
+    wrap(object3d: Object3D): BaseObject;
+    private wrapObject;
+    /**
+     * 统一的添加入口
+     * 替代原有的 addBaseObject 私有方法，公开给 spawn 使用
+     */
+    add<T extends BaseObject = BaseObject>(baseObject: T, target?: BaseObject | string | null): Promise<T>;
+    private _addLogic;
+    /** @deprecated Use objects.get(uuid). This method also requires an exact UUID. */
+    getObject<T extends BaseObject = BaseObject>(uuid: string): T | undefined;
+    /** @deprecated Use objects.get(uuid). UUIDs identify at most one object. */
+    getAllObject<T extends BaseObject = BaseObject>(uuid: string): T[];
+    /** @deprecated Use BaseObject.setKey(uuid) for explicit identity changes. */
+    updateBaseObjectKey(baseObject: BaseObject, ops?: {
+        keyType?: string;
+        uuid?: string;
+    }): string;
+    erase(...args: (string | BaseObject)[]): void;
+    private eraseObjects;
+    update(delta: number, elapsed: number): void;
+    setSize(width: number, height: number): void;
+    eraseAll(): void;
+    private _serializer;
+    exportBaseObject(...args: Parameters<SceneSerializer['exportBaseObject']>): SceneSnapshot;
+    restoreBaseObject(...args: Parameters<SceneSerializer['restoreBaseObject']>): Promise<BaseObject<Object3D< Object3DEventMap>>>;
+    dispose(): void;
+}
+
+declare class LeadPages extends OrigonPages<Lead_2> {
+    options: Options_11;
+    get lead(): Lead_2;
+    constructor(options: Options_11);
+    addLead(scene: Scene, sceneResources: SceneResources_2, index?: number): Lead_2;
+    removePage(index: number): void;
+    setPageActive(index: number): void;
+    setSize(width: number, height: number): void;
+}
+
+declare type LeadParams = {};
+
+declare type LeadParams_2 = {};
+
 declare namespace Lights {
     export {
         AmbientLight,
@@ -799,6 +2828,136 @@ declare namespace Lights {
     }
 }
 
+declare interface LineMessage {
+    projection?: ProjectionOptions;
+    useGroups?: 0 | 1 | 2;
+    splitPolygons?: number;
+}
+
+declare class LineObject extends MeshObject<MeshLineGeometry | BufferGeometry, MeshLineMaterial> {
+    objectType: string;
+    options: LineObjectOptions;
+    private rtcRenderBinding?;
+    constructor(options?: Partial<LineObjectOptions>);
+    get material(): MeshLineMaterial;
+    create(): Promise<void>;
+    private createWithWorker;
+    private createLocal;
+    setGeometry(nodes: PointsInput_2, setPointWidth?: (p: number) => any, useRTC?: boolean, rtcCenter?: Vector3): void;
+    createMaterial(materialOptions: Omit<MeshLineMaterialParameters, 'resolution'>): MeshLineMaterial;
+    resize(w: number, h: number): void;
+    handleMaterialChange(mat: MeshLineMaterial | null): void;
+    animate({ duration, delay, repeat, lineLoop, onRepeat, onUpdate, onComplete, startShow, }?: {
+        duration?: number;
+        delay?: number;
+        repeat?: number;
+        lineLoop?: boolean;
+        onComplete?: (...args: any[]) => void;
+        onUpdate?: (...args: any[]) => void;
+        onRepeat?: (...args: any[]) => void;
+        startShow?: boolean;
+    }): void;
+    stopAnimation(material?: MeshLineMaterial): void;
+    render(): void;
+    dispose(): void;
+}
+
+declare interface LineObjectOptions {
+    geometry?: BufferGeometry;
+    material?: MeshLineMaterial;
+    coordinatesArr?: number[][][];
+    metaArray?: number[][];
+    globalMeta?: number[];
+    useWorker?: boolean;
+    projection?: ProjectionOptions | 'cesium' | 'sphere';
+    splitPolygons?: number;
+    useGroups?: 0 | 1 | 2;
+    setPointWidth?: (p: number) => any;
+    lineWidthArr?: number[];
+    cacheKey?: string;
+    userData?: Record<string, any>;
+    useFloat64Array?: boolean;
+    useRTC?: boolean;
+    onCacheMiss?: (options: Partial<LineObjectOptions>) => Partial<LineObjectOptions> | Promise<Partial<LineObjectOptions>>;
+}
+
+declare type Listener_2 = (event?: DispatcherEvent) => void;
+
+declare class Loader {
+    loadingManager: LoadingManager;
+    loaders: Map<string, any>;
+    loaderConfigs: Map<string, LoaderConfig>;
+    loadObj: Asset[];
+    delLoadArr: string[];
+    assets: Map<string, Texture | Object3D | any>;
+    event: EventEmitter;
+    options: Options_9;
+    scene: Scene;
+    private disposed;
+    readonly resources: ResourceRegistry;
+    private assetLeases;
+    private cachedRequests;
+    private pendingRequests;
+    constructor(options: Options_9);
+    initLoaderConfigs(): void;
+    emit(eventName: string, ...args: any[]): void;
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    getAsset(src: `${string}.${TypeImage}`): Texture;
+    getAsset(src: `${string}.${TypeMedia}`): VideoTexture;
+    getAsset(src: `${string}.${TypeGLTF}`): {
+        scene: Object3D;
+    };
+    getAsset(src: `${string}.${TypeLottie}`): Texture;
+    getAsset(src: `${string}.${TypeJSON}`): any;
+    getAsset(src: `${string}.${TypeGzipJSON}`): any;
+    getAsset(src: `${string}.${TypeEXR}`): DataTexture;
+    getAsset(src: string): Texture;
+    getAssetType(src: string): "images" | "json" | "gltf" | "exr" | "media" | "gzipJson" | "lottie" | undefined;
+    private loaderKey;
+    getLoader(type: string, options?: AssetOptions): any;
+    add(src: string | string[], options?: AssetOptions): void;
+    getSrcByAsset(asset: Texture | Object3D | any, assets?: Map<string, any>): string | undefined;
+    get textureAssets(): Map<string, Texture<unknown, TextureEventMap>>;
+    loadAll(): Promise<Texture<unknown, TextureEventMap>[]>;
+    load(src: `${string}.${TypeImage}`, options?: AssetOptions): Promise<Texture>;
+    load(src: `${string}.${TypeMedia}`, options?: AssetOptions): Promise<VideoTexture>;
+    load(src: `${string}.${TypeGLTF}`, options?: AssetOptions): Promise<{
+        scene: Object3D;
+    }>;
+    load(src: `${string}.${TypeLottie}`, options?: AssetOptions): Promise<Texture>;
+    load(src: `${string}.${TypeJSON}`, options?: AssetOptions): Promise<any>;
+    load(src: `${string}.${TypeGzipJSON}`, options?: AssetOptions): Promise<any>;
+    load(src: `${string}.${TypeEXR}`, options?: AssetOptions): Promise<DataTexture>;
+    load(src: string, options?: AssetOptions): Promise<Texture>;
+    private publishAsset;
+    private assetScenes;
+    private isResourceAsset;
+    private disposeAsset;
+    getUnusedAssets(): string[];
+    dispose(): void;
+}
+
+declare interface LoaderConfig {
+    create: (manager: LoadingManager, options?: AssetOptions) => any;
+    setPath?: (loader: any, prefix: string) => void;
+    setResponseType?: (loader: any, responseType: string) => void;
+    requiresDraco?: boolean;
+}
+
+declare class LoaderPages extends OrigonPages<Loader> {
+    options: Options_10;
+    get loader(): Loader;
+    constructor(options: Options_10);
+    addLoader(scene: Scene, index?: number): Loader;
+    removePage(index: number): void;
+}
+
+declare interface LoaderParams {
+    anisotropy: number;
+    prefix?: string;
+    simpleTexture4deleted?: boolean;
+}
+
 /** Copy once and redirect every user in this scene, including its SceneResources aliases. */
 export declare function makeMaterialSceneLocal<T extends VisSceneDocument>(document: T, assetId: string, sceneId: string, newAssetId: string): T;
 
@@ -863,7 +3022,7 @@ declare class Map_4 extends Base_3 {
         Plane: Plane;
         PlaneShadow: PlaneShadow;
         Sphere: Sphere;
-        Sprite: Sprite;
+        Sprite: Sprite_2;
         Box: Box;
         Circle: Circle;
         Tube: TubeObject;
@@ -879,7 +3038,7 @@ declare class Map_4 extends Base_3 {
         Line: LineObject;
         Group: typeof GroupObject;
     };
-    protected get defaultCameraUp(): THREE.Vector3;
+    protected get defaultCameraUp(): _THREE.Vector3;
     protected onRuntimeReady(): Promise<void>;
     protected prepareInitialCamera(): Promise<void>;
     private mapBoundaryMatrix?;
@@ -899,7 +3058,7 @@ declare class Map_4 extends Base_3 {
     ensureParentBackground(): Promise<{
         planeWidth: number;
         planeHeight: number;
-        center: THREE.Vector3;
+        center: _THREE.Vector3;
     } | undefined>;
     clearContinentsBackground(): void;
     ensureContinentsBackground(): Promise<void>;
@@ -999,7 +3158,7 @@ declare class Map_4 extends Base_3 {
      */
     private applyRegionObjectState;
     /** Internal: 仅由 SceneManager 在隔离页面调用，成功后才对外提交。 */
-    rebuildRegion(targetAdcode: number, switchKey?: string): Promise<void>;
+    rebuildRegion(targetAdcode: number, switchKey?: string, force?: boolean): Promise<void>;
     private rebuildRegionGeometry;
     /** 候选区域提交后的相机过渡，不参与场景序列化。 */
     playRegionEnterTransition({ duration, sourceCamera, preparedCamera, onPrepared, }: MapRegionEnterTransitionOptions): Promise<void>;
@@ -1038,6 +3197,22 @@ declare interface MapAssetSources {
     };
 }
 
+/** Authored map extent. Inline geometry travels with the scene and needs no script. */
+export declare type MapBoundaryData = {
+    version: 1;
+    mode: 'builtin';
+    adcode: number;
+} | {
+    version: 1;
+    mode: 'regions' | 'custom';
+    adcode: number;
+    geojson: GeoJSON_3;
+    /** Independent perimeter; optional for documents saved before this field existed. */
+    outlineGeojson?: GeoJSON_3;
+    regions?: number[];
+    name?: string;
+};
+
 declare interface MapCameraFitReference {
     lookat: MapCameraPose;
     adcode?: number;
@@ -1075,6 +3250,7 @@ declare interface MapLabelStyle {
 
 declare interface MapOptions extends BaseOptions {
     adcode: number;
+    mapData?: MapBoundaryData;
     sceneBindings?: MapSceneBindings;
     center?: [number, number];
     parentBg?: boolean | number;
@@ -1084,6 +3260,8 @@ declare interface MapOptions extends BaseOptions {
     continentsBg?: boolean;
     continentsBgDepth?: number;
     mapDepth?: number;
+    /** Inset bevel as a fraction of the map thickness, 0..0.25. */
+    mapBevel?: number;
     fixGeojson?: Record<string, string>;
     showDistrict?: boolean;
     showLabel?: boolean | 'lite';
@@ -1193,6 +3371,13 @@ export declare interface MaterialAlias {
     locked?: boolean;
 }
 
+declare interface MaterialAlias_2 {
+    readonly key: string;
+    readonly material: Material;
+    readonly locked: boolean;
+    readonly transient: boolean;
+}
+
 export declare interface MaterialAsset {
     id: string;
     revision: number;
@@ -1252,6 +3437,12 @@ export declare function materializeSceneMaterials<T extends SceneViewportDocumen
 /** One validation context per batch; never cached across caller mutations. */
 export declare function materializeSceneMaterialsBatch<T extends SceneViewportDocument>(scenes: readonly T[], library?: MaterialAsset[]): T[];
 
+declare interface MaterialRegistrationOptions {
+    locked?: boolean;
+    ownership?: ResourceOwnership;
+    transient?: boolean;
+}
+
 /** Serializable project data. This deliberately contains no THREE instances or GPU ownership. */
 export declare type MaterialScope = {
     kind: 'project';
@@ -1292,23 +3483,317 @@ export declare function mergeProjectMaterials(target: VisSceneDocument, incoming
     idMap: Map<string, string>;
 };
 
+declare class MeshLineGeometry extends BufferGeometry {
+    type: string;
+    private pointCount;
+    private _points;
+    private shape;
+    private shapeFunction;
+    matrixWorld: Matrix4;
+    private useRTC;
+    private rtcCenter;
+    constructor(points?: PointsInput_2, shape?: 'none' | 'taper' | 'custom', shapeFunction?: WidthCallback, useRTC?: boolean, rtcCenter?: Vector3);
+    private convertToVector3Array;
+    setMatrixWorld(matrixWorld: Matrix4): void;
+    setPoints(points: PointsInput_2, shapeFunction?: WidthCallback, useRTC?: boolean, rtcCenter?: Vector3): void;
+    private initializeGeometry;
+    private updateGeometry;
+    /**
+     * 获取相对于 RTC 中心的坐标
+     */
+    private getRelativePosition;
+    get points(): Vector3[];
+    set points(value: PointsInput_2);
+    updatePoints(points: PointsInput_2, shapeFunction?: WidthCallback): void;
+    setShape(shape: 'none' | 'taper' | 'custom', shapeFunction?: WidthCallback): void;
+    getRTCCenter(): Vector3;
+    setUseRTC(useRTC: boolean): void;
+    getUseRTC(): boolean;
+    setRTCCenter(center: Vector3): void;
+}
+
+declare class MeshLineMaterial extends NodeMaterial {
+    uniforms: Record<string, {
+        value: any;
+    }>;
+    uniformsNeedUpdate: boolean;
+    type: string;
+    private authoredTransparent;
+    constructor(parameters?: MeshLineMaterialParameters);
+    private rebuildNodes;
+    copy(source: this): this;
+    toJSON(meta?: Parameters<Material['toJSON']>[0]): ShaderMaterialJSON;
+    get color(): Color;
+    set color(value: ColorRepresentation);
+    get opacity(): number;
+    set opacity(value: number);
+    get alphaTest(): number;
+    set alphaTest(value: number);
+    get map(): Texture | null;
+    set map(value: Texture | null);
+    get alphaMap(): Texture | null;
+    set alphaMap(value: Texture | null);
+    get repeat(): Vector2_2;
+    set repeat(value: Vector2_2);
+    get lineWidth(): number;
+    set lineWidth(value: number);
+    get sizeAttenuation(): boolean;
+    set sizeAttenuation(value: boolean);
+    get rtcOffset(): Vector3;
+    set rtcOffset(value: Vector3);
+    get viewRotation(): Matrix4;
+    set viewRotation(value: Matrix4);
+    get modelMatrix(): Matrix4;
+    set modelMatrix(value: Matrix4);
+    get useRTC(): boolean;
+    set useRTC(value: boolean);
+    /**
+     * 更新 RTC 相关的 uniforms
+     * @param center RTC 中心点（通常是物体的世界坐标原点或几何中心）
+     * @param cameraMatrixWorld 相机的世界矩阵
+     * @param objectMatrixWorld 物体的世界矩阵（可选，用于支持缩放和旋转）
+     */
+    updateRTC(center: Vector3, cameraMatrixWorld: Matrix4, objectMatrixWorld?: Matrix4): void;
+    /**
+     * 从 Three.js 原生解析好的 ShaderMaterial 中还原出 MeshLineMaterial
+     * 用于反序列化场景
+     */
+    static fromParsedShaderMaterial(shaderMat: ShaderMaterial | MeshLineMaterial): MeshLineMaterial;
+}
+
+declare interface MeshLineMaterialParameters extends MaterialParameters {
+    fog?: boolean;
+    /**
+     * Line width
+     * @default 1
+     */
+    lineWidth?: number;
+    /**
+     * Line color
+     * @default '#ffffff'
+     */
+    color?: ColorRepresentation;
+    opacity?: number;
+    /**
+     * Texture map
+     */
+    map?: Texture;
+    /**
+     * Dash offset for dashed lines
+     * @default 0
+     */
+    dashOffset?: number;
+    /**
+     * Dash array for dashed lines
+     * @default 0
+     */
+    dashArray?: number;
+    /**
+     * Dash ratio for dashed lines
+     * @default 0
+     */
+    dashRatio?: number;
+    /**
+     * Whether to apply size attenuation (alias for attenuate)
+     * @default true
+     */
+    sizeAttenuation?: boolean;
+    offsetLoop?: boolean;
+    /**
+     * Scale down factor
+     * @default 0
+     */
+    scaleDown?: number;
+    /**
+     * Alpha map texture
+     */
+    alphaMap?: Texture | undefined;
+    alphaTest?: number;
+    /**
+     * Texture repeat
+     * @default Vector2(1, 1)
+     */
+    repeat?: Vector2_2;
+    /**
+     * Screen resolution for line width calculation
+     */
+    resolution?: Vector2_2;
+    offset?: Vector2_2;
+}
+
+declare class MeshObject<G extends BufferGeometry = BufferGeometry, M extends Material | Material[] = Material | Material[]> extends BaseObject<Mesh<G, M>> {
+    objectType: string;
+    constructor(geometryOrMesh?: G | Mesh<G, M>, material?: M);
+}
+
+/** A GLTF-backed group with serializable playback and isolated instances. */
+declare class ModelObject extends GroupObject {
+    options: ModelOptions;
+    mixer: _THREE.AnimationMixer | null;
+    clips: _THREE.AnimationClip[];
+    actions: _THREE.AnimationAction[];
+    actionStates: Record<string, boolean>;
+    objectType: string;
+    constructor(options?: ModelOptions);
+    create(): Promise<void>;
+    render(): void;
+    /**
+     * Set animation clips for the model
+     * @param clips Array of animation clips from GLTF
+     */
+    setClips(clips: _THREE.AnimationClip[]): void;
+    /**
+     * Play all animation clips
+     */
+    playAllClips(): void;
+    /**
+     * Play a specific animation clip by name
+     * @param clipName Name of the animation clip to play
+     */
+    playClip(clipName: string): void;
+    /**
+     * Stop a specific animation clip by name
+     * @param clipName Name of the animation clip to stop
+     */
+    stopClip(clipName: string): void;
+    /**
+     * Stop all animation clips
+     */
+    stopAllClips(): void;
+    /**
+     * Set the playback speed for all animations
+     * @param speed Playback speed (1.0 = normal speed)
+     */
+    setPlaybackSpeed(speed: number): void;
+    /**
+     * Get the current playback speed
+     */
+    getPlaybackSpeed(): number;
+    /**
+     * Check if a specific animation is playing
+     * @param clipName Name of the animation clip
+     */
+    isPlaying(clipName: string): boolean;
+    /**
+     * Get all available animation clip names
+     */
+    getClipNames(): string[];
+    rebuildFromScene(): Promise<void>;
+    instantiate(ops?: Parameters<GroupObject['instantiate']>[0]): Promise<this>;
+    /**
+     * Update animations - should be called in render loop
+     * @param deltaTime Time elapsed since last frame
+     */
+    update(deltaTime: number): void;
+    /**
+     * Dispose of resources including animation mixer
+     */
+    dispose(): void;
+    private syncPlayingClipNames;
+}
+
+declare interface ModelOptions {
+    src?: string;
+    autoPlay?: boolean;
+    playbackSpeed?: number;
+    serializedClips?: SerializedClip[];
+    playingClipNames?: string[];
+}
+
 declare class Mountain extends GroupObject {
     objectType: string;
-    options: Required<Omit<Options_9, 'bbox'>> & Pick<Options_9, 'bbox'>;
+    options: Required<Omit<Options_22, 'bbox'>> & Pick<Options_22, 'bbox'>;
     extrudePolygon: ExtrudePolygonObject;
-    constructor(options: Options_9);
+    constructor(options: Options_22);
     geojson2Meta(geojson: GeoJSON_4): {
         coords: Position[][];
         properties: GeoJsonProperties;
     }[];
     create(): Promise<void>;
-    setNoise(geometry: THREE.BufferGeometry, image: HTMLImageElement, maxHeight?: number): void;
+    setNoise(geometry: _THREE.BufferGeometry, image: HTMLImageElement, maxHeight?: number): void;
     rebuildFromScene(): void;
 }
 
+declare const MOUSE_BUTTON: {
+    readonly LEFT: 1;
+    readonly RIGHT: 2;
+    readonly MIDDLE: 4;
+};
+
+declare type MOUSE_BUTTON = (typeof MOUSE_BUTTON)[keyof typeof MOUSE_BUTTON];
+
+declare type mouseButtonAction =
+| typeof ACTION.ROTATE
+| typeof ACTION.TRUCK
+| typeof ACTION.SCREEN_PAN
+| typeof ACTION.OFFSET
+| typeof ACTION.DOLLY
+| typeof ACTION.ZOOM
+| typeof ACTION.NONE;
+
+declare interface MouseButtons {
+    left: mouseButtonAction;
+    middle: mouseButtonAction;
+    right: mouseButtonAction;
+    wheel: mouseWheelAction;
+}
+
+declare type mouseWheelAction =
+| typeof ACTION.ROTATE
+| typeof ACTION.TRUCK
+| typeof ACTION.SCREEN_PAN
+| typeof ACTION.OFFSET
+| typeof ACTION.DOLLY
+| typeof ACTION.ZOOM
+| typeof ACTION.NONE;
+
 /** Reparent/reorder roots with caller-computed local matrices, without copying their descendants. */
 export declare function moveObjectsDocument(before: VisSceneDocument, sceneId: string, ids: readonly string[], parentUuid: string, order: readonly string[], matrices: ReadonlyMap<string, MatrixState>): VisSceneDocument;
 
+declare type multiTouchAction =
+| typeof ACTION.TOUCH_DOLLY_ROTATE
+| typeof ACTION.TOUCH_DOLLY_TRUCK
+| typeof ACTION.TOUCH_DOLLY_OFFSET
+| typeof ACTION.TOUCH_ZOOM_ROTATE
+| typeof ACTION.TOUCH_ZOOM_TRUCK
+| typeof ACTION.TOUCH_ZOOM_OFFSET
+| typeof ACTION.TOUCH_DOLLY
+| typeof ACTION.TOUCH_ZOOM
+| typeof ACTION.TOUCH_ROTATE
+| typeof ACTION.TOUCH_TRUCK
+| typeof ACTION.TOUCH_SCREEN_PAN
+| typeof ACTION.TOUCH_OFFSET
+| typeof ACTION.NONE;
+
+declare class NodeObject extends BaseObject<CSSObject> {
+    objectType: string;
+    options: Options_5;
+    pickObject?: Sprite;
+    object3d: CSS2DObject;
+    element: HTMLDivElement;
+    private static sharedObserver?;
+    private static observerMap;
+    private observedElement?;
+    private visibilityTimer?;
+    private clearVisibilityTracking;
+    constructor(options: Options_5);
+    /**
+     * 启用碰撞检测跟踪
+     * @param priority 优先级，数值越大越优先显示，默认 0
+     */
+    trackCollision(priority?: number): void;
+    /**
+     * 停止碰撞检测跟踪
+     */
+    untrackCollision(): void;
+    setChildren(children: HTMLElement): void;
+    showAndEnsureVisible(): void;
+    private moveElementToViewport;
+    private ensureVisible;
+    protected createPointerBinding(type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): () => void;
+    dispose(): void;
+}
+
 /** Keep saved texture/image identities stable across runtime namespace and revision changes. */
 export declare function normalizeMaterialDefinition<T extends Record<string, any>>(input: T): T;
 
@@ -1324,7 +3809,72 @@ declare type ObjectIndex = Map<string, {
     lengths: readonly number[];
 }>;
 
+/** Export/rebuild dependencies never acquire resource leases. */
+declare class OptionMaterialDependencies {
+    private objects;
+    private materials;
+    private recovered;
+    private resources;
+    constructor(resources: ResourceRegistry);
+    track(object: BaseObject): void;
+    private removeOwner;
+    forget(object: BaseObject): void;
+    definition(material: Material): any;
+    releaseUnused(object: BaseObject): void;
+    resolve(options: any, scope: ResourceScope, live: (uuid: string) => Material | undefined): void;
+    replace(oldMaterial: Material, material: Material): void;
+    dispose(): void;
+}
+
 declare interface Options {
+    container: HTMLElement;
+    helper?: boolean;
+    controls?: Partial<ControlsParams>;
+    renderer?: Partial<RendererParams>;
+    composer?: Partial<ComposerParams>;
+    loader?: Partial<LoaderParams>;
+    scene?: Partial<SceneParams>;
+    camera?: Partial<CameraParams> | PerspectiveCamera;
+    bloom?: boolean;
+    bloomParams?: Partial<BloomParams>;
+    ssao?: boolean;
+    ssaoParams?: Partial<SSAOParams>;
+    crossOpacity?: boolean;
+    css2DRenderer?: boolean;
+    css2DRendererParams?: Partial<CSSRendererParams>;
+    css3DRenderer?: boolean;
+    css3DRendererParams?: Partial<CSSRendererParams>;
+    /** @deprecated WebGPU is built in; dependency injection is no longer needed. */
+    WebGPUTHREE?: unknown;
+    /** @deprecated Configure the built-in renderer using renderer options. */
+    WebGPURenderer?: unknown;
+    attributesWorkerVersion?: string;
+    attributesWorkerMaxWorkers?: number;
+}
+
+declare interface Options_10 {
+    loaderParams: LoaderParams;
+    resources?: ResourceRegistry;
+}
+
+declare interface Options_11 {
+    leadParams?: LeadParams;
+    pencil: Pencil;
+}
+
+declare interface Options_12 {
+    leadParams?: LeadParams_2;
+    pencil: Pencil;
+}
+
+declare interface Options_13 {
+    maxWorkers?: number;
+    dbName?: string;
+    cacheVersion?: string;
+    maxCacheSize?: number;
+}
+
+declare interface Options_14 {
     /** @deprecated Legacy generation scope, read only when importing old snapshots. */
     uuid?: string;
     areaGroup?: boolean;
@@ -1344,49 +3894,42 @@ declare interface Options {
     lineOffset?: number;
     bbox?: number[];
     topSegments?: number;
+    bevelRatio?: number;
     conic?: boolean;
     castShadow?: boolean;
     mergeSide?: boolean;
     hasExtrudeLine?: boolean;
     materialOptions: {
-        topMat: THREE.Material;
-        sideMat?: THREE.Material;
+        topMat: _THREE.Material;
+        sideMat?: _THREE.Material;
         lineMat?: MeshLineMaterial;
         extrudeLineMat?: MeshLineMaterial;
-        bgTopMat?: THREE.Material;
-        bgSideMat?: THREE.Material;
-        bgLineMat?: MeshLineMaterial;
-        bgExtrudeLineMat?: MeshLineMaterial;
-    };
-    onTop?: number;
-    bloom?: boolean;
-}
-
-declare interface Options_10 {
-    width: number;
-    height: number;
-    material?: THREE.Material;
-    color?: string;
-    map?: THREE.Texture | null;
+        bgTopMat?: _THREE.Material;
+        bgSideMat?: _THREE.Material;
+        bgLineMat?: MeshLineMaterial;
+        bgExtrudeLineMat?: MeshLineMaterial;
+    };
+    onTop?: number;
+    bloom?: boolean;
 }
 
-declare interface Options_2 {
+declare interface Options_15 {
     radius?: number;
     rotationY?: number;
 }
 
-declare interface Options_3 {
+declare interface Options_16 {
     radius?: number;
 }
 
-declare interface Options_4 {
+declare interface Options_17 {
     sprite?: boolean;
 }
 
-declare interface Options_5 {
+declare interface Options_18 {
     materialOptions: {
-        topMat: THREE.Material;
-        sideMat: THREE.Material;
+        topMat: _THREE.Material;
+        sideMat: _THREE.Material;
         lineMat: MeshLineMaterial;
     };
     scale: number;
@@ -1395,7 +3938,7 @@ declare interface Options_5 {
     geojsonSource: string;
 }
 
-declare interface Options_6 {
+declare interface Options_19 {
     uuid?: string;
     jsonUrl: string;
     projection: {
@@ -1411,7 +3954,15 @@ declare interface Options_6 {
     materialOptions?: Record<string, THREE.Material>;
 }
 
-declare interface Options_7 {
+declare interface Options_2 {
+    sceneController: ScenePages;
+    cameraController: CameraPages;
+    rendererController: RendererController;
+    composerParams: ComposerParams;
+    resources?: ResourceRegistry;
+}
+
+declare interface Options_20 {
     uuid?: string;
     jsonUrl: string;
     projection: {
@@ -1424,20 +3975,20 @@ declare interface Options_7 {
     material?: MeshLineMaterial;
 }
 
-declare interface Options_8 {
+declare interface Options_21 {
     uuid?: string;
     jsonUrl: string;
     projection: {
         center: [number, number];
         scale: number;
     };
-    material: THREE.Material;
+    material: _THREE.Material;
     type: string;
     cacheKey?: string;
     oArr?: number[];
 }
 
-declare interface Options_9 {
+declare interface Options_22 {
     geojson: GeoJSON_4;
     projection: {
         center: [number, number];
@@ -1449,9 +4000,120 @@ declare interface Options_9 {
     bbox?: number[];
 }
 
+declare interface Options_23 {
+    width: number;
+    height: number;
+    material?: _THREE.Material;
+    color?: string;
+    map?: _THREE.Texture | null;
+}
+
+declare interface Options_3 {
+    width: number;
+    height: number;
+}
+
+declare interface Options_4 {
+    width: number;
+    height: number;
+    rendererParams: RendererParams;
+}
+
+declare interface Options_5 {
+    children?: HTMLElement;
+    position?: Vector3;
+    type?: '2d' | '3d' | '3dSprite';
+}
+
+declare interface Options_6 {
+    controlsParams: ControlsParams;
+    acceptsInput?: (event: MouseEvent) => boolean;
+}
+
+declare interface Options_7 {
+    renderer: WebGPURenderer;
+    scene: Scene_2;
+    /** Authored page identity when scene is a shared overlay. */
+    viewScene?: Scene_2;
+    camera: Camera_2;
+}
+
+declare interface Options_8 {
+    sceneController: ScenePages;
+    /** Editor overlays live outside the authored scene and its render passes. */
+    helperScene?: Scene_2;
+    cameraController: CameraPages;
+    container: HTMLElement;
+    resources?: ResourceRegistry;
+}
+
+declare interface Options_9 {
+    prefix?: string;
+    simpleTexture4deleted?: boolean;
+    anisotropy: number;
+    scene: Scene | null;
+    resources?: ResourceRegistry;
+}
+
+declare class OrigonPages<T = any> {
+    event: EventEmitter;
+    controllerMap: Map<T, Pages>;
+    activeIndex: number;
+    controller: T;
+    activeControllerSet: Set<T>;
+    addController(c: T, index?: number): T;
+    removePage(index: number, cb?: (c: T) => void): void;
+    setPageActive(index: number, cb?: (c: T, r: boolean) => void): void;
+    update(delta: number, elapsed: number): void;
+    dispose(): void;
+}
+
 /** Pack an export copy only; preserve the editor's independent scene snapshots. */
 export declare function packSceneDocumentResources<T extends VisSceneDocument>(document: T): T;
 
+/** Page identities are independent of Three's 32 rendering layers. */
+declare class Pages {
+    private readonly indices;
+    get size(): number;
+    private validate;
+    /** Legacy low-32-page view; use isEnabled()/size for page membership. */
+    get mask(): number;
+    set mask(value: number);
+    set(layer: number): void;
+    enable(layer: number): void;
+    enableAll(): void;
+    toggle(layer: number): void;
+    disable(layer: number): void;
+    disableAll(): void;
+    isEnabled(layer: number): boolean;
+    getMinDisabledLayer(): number | null;
+    getMinEnabledLayer(): number | null;
+}
+
+declare class Panel {
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D | null;
+    name: string;
+    fg: string;
+    bg: string;
+    gradient: CanvasGradient | null;
+    id: number;
+    PR: number;
+    WIDTH: number;
+    HEIGHT: number;
+    TEXT_X: number;
+    TEXT_Y: number;
+    GRAPH_X: number;
+    GRAPH_Y: number;
+    GRAPH_WIDTH: number;
+    GRAPH_HEIGHT: number;
+    constructor(name: string, fg: string, bg: string);
+    private createGradient;
+    initializeCanvas(): void;
+    update(value: number, maxValue: number, decimals?: number): void;
+    updateGraph(valueGraph: number, maxGraph: number): void;
+}
+
 /** Clone each affected ancestor/children array once, without visiting other subtrees. */
 export declare function patchIndexedSceneObjects(root: any, updates: ReadonlyMap<string, {
     state: Record<string, any>;
@@ -1469,6 +4131,285 @@ export declare function patchSceneStructureTransactionDocument(document: VisScen
 /** Own only the small viewport payload and copy the camera's ancestor path. */
 export declare function patchSceneViewportDocument(document: VisSceneDocument, sceneId: string, patch: SceneViewportPatch): VisSceneDocument;
 
+declare class Pencil {
+    readonly resources: ResourceRegistry;
+    readonly ready: Promise<void>;
+    options: Omit<DeepRequiredOptions, 'controls' | 'loader' | 'css2DRendererParams' | 'css3DRendererParams'> & Pick<Options, 'controls' | 'loader'> & {
+        css2DRendererParams: CSSRendererParams;
+        css3DRendererParams: CSSRendererParams;
+    };
+    composerController?: Composer;
+    rendererController: RendererController;
+    cssRendererController?: CSSRendererController;
+    cameraController: CameraPages;
+    controlsController: ControlsPages;
+    transformController?: TransformControlsController;
+    sceneController: ScenePages;
+    helperController?: HelperController;
+    private _helperScene?;
+    /** Drawn only in the editor, after the authored scene's postprocessing. */
+    get helperScene(): Scene_2< Object3DEventMap>;
+    private sceneCapture?;
+    loaderController: LoaderPages;
+    leadController: LeadPages;
+    sceneResourcesController: SceneResourcesPages;
+    stats?: Stats;
+    private disposeStats?;
+    private resizeObserver;
+    raycaster: Raycaster;
+    private maxBackufferArea;
+    installPlugins: Map<string, any>;
+    attributesWorker: AttributesWorker;
+    getPlugin(name: string): any;
+    get renderer(): WebGPURenderer;
+    get maxAnisotropy(): number;
+    get controls(): CameraControls;
+    private _cameraPositon;
+    private _cameraTarget;
+    get cameraPositon(): Vector3_2;
+    get cameraTarget(): Vector3_2;
+    get camera(): PerspectiveCamera;
+    get scene(): Scene_2< Object3DEventMap>;
+    get loader(): Loader;
+    get lead(): Lead_2;
+    get sceneResources(): SceneResources_2;
+    event: EventEmitter;
+    timer: Timer;
+    readonly animations: AnimationScope;
+    userData: Record<string, any>;
+    static options: {
+        helper: boolean;
+        controls: boolean;
+        renderer: {
+            forceWebGL: boolean;
+            antialias: boolean;
+            devicePixelRatio: number;
+            powerPreference: string;
+            toneMappingExposure: number;
+            alpha: boolean;
+            outputColorSpace: "srgb";
+            logarithmicDepthBuffer: boolean;
+            reversedDepthBuffer: boolean;
+            preserveDrawingBuffer: boolean;
+            stencil: boolean;
+            depth: boolean;
+        };
+        composer: {
+            multisampling: number;
+            premultiplieAlpha: boolean;
+        };
+        scene: {
+            background: null;
+        };
+        camera: {
+            fov: number;
+            near: number;
+            far: number;
+            up: Vector3_2;
+        };
+        bloom: boolean;
+        bloomParams: {
+            threshold: number;
+            strength: number;
+            radius: number;
+            bloomAlphaType: number;
+        };
+        ssao: boolean;
+        loader: {
+            prefix: string;
+        };
+        ssaoParams: {
+            kernelRadius: number;
+            minDistance: number;
+            maxDistance: number;
+        };
+        css2DRenderer: boolean;
+        css2DRendererParams: {
+            zIndex?: string;
+            container?: HTMLElement;
+            collision?: {
+                enabled?: boolean;
+                padding?: number;
+                throttleTime?: number;
+                viewportMargin?: number;
+            };
+        };
+        css3DRenderer: boolean;
+        css3DRendererParams: {
+            zIndex?: string;
+            container?: HTMLElement;
+            collision?: {
+                enabled?: boolean;
+                padding?: number;
+                throttleTime?: number;
+                viewportMargin?: number;
+            };
+        };
+        attributesWorkerVersion: string;
+        attributesWorkerMaxWorkers: number;
+    };
+    private TweenRaf;
+    private tweenUpdateRaf;
+    private cancelTweenRaf;
+    constructor(options: Options);
+    initStats(): void;
+    use(plugin: any, ...args: any[]): void;
+    addPage({ sceneOptions, cameraOptions, }?: {
+        sceneOptions?: SceneParams;
+        cameraOptions?: CameraParams;
+    }): number;
+    removePage(index: number): void;
+    showPage(index: number): void;
+    /** Rebind editor tools and reapply the active viewport after a scene restore. */
+    refreshActiveView(): void;
+    private pageActiveIndex;
+    private pages;
+    private init;
+    private initComposer;
+    private initCSSRenderer;
+    initTransformControls(): void;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    initResizeObserver(): void;
+    private userSetDprCache;
+    private handeleResize;
+    setDevicePixelRatio(userSetDprCache: number): void;
+    private viewPadding;
+    getViewViewport(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    getClientViewViewport(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    getScreenPositionFromNDC(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+    getPointerNDC(clientX: number, clientY: number, requireInside?: boolean): {
+        x: number;
+        y: number;
+    } | undefined;
+    setViewPadding(top?: number, right?: number, bottom?: number, left?: number): void;
+    /** Optional host filters; these are never serialized into a scene. */
+    renderObjectFilter?: (object: Object3D_2) => boolean;
+    pickObjectFilter?: (object: Object3D_2) => boolean;
+    /** Certify host raycasts that only hit this object and never stop child traversal. */
+    pickRaycastCanBeSkipped?: (object: Object3D_2) => boolean;
+    pick(event: MouseEvent, objects?: Object3D_2[], recursive?: boolean): {
+        object: Object3D_2< Object3DEventMap>;
+        index: number | undefined;
+        intersects: Intersection<Object3D_2< Object3DEventMap>>[];
+    } | undefined;
+    render(): void;
+    /** Capture only authored content without advancing animation or touching editor tools. */
+    captureImage(options?: SceneCaptureOptions): Promise<HTMLCanvasElement>;
+    private renderFrame;
+    private renderHelpers;
+    private renderSuspensions;
+    private rendering;
+    private resumeAfterSuspension;
+    /** 构建期间禁止提交中间帧；释放时恢复此前运行状态或期间的启动请求。 */
+    suspendRendering(): () => void;
+    start(): void;
+    stop(): void;
+    private setAnimationLoop;
+    private stopRenderingLoop;
+    autoRotate(speed: number): void;
+    private pipCameraControls?;
+    private pipSourceCamera?;
+    private isInsidePipViewport;
+    private updatePipCameraViewport;
+    showPipViewport(state: typeof Composer.prototype.pipViewportState): void;
+    private releasePipView;
+    _isDispose: boolean;
+    dispose(): void;
+}
+
+declare class Pick_2 {
+    pencil: Pencil;
+    enabled: boolean;
+    private pickFunctionsMap;
+    private pickNodeFunctionsMap;
+    private nodePointerOwners;
+    private pickFunctionsMapIndex;
+    private pickNodeFunctionsMapIndex;
+    private activeObjects;
+    private activeObject;
+    private prevActiveObjects;
+    private objCallbackMap;
+    private pickListener;
+    /** 是否有 enterOnStop 事件注册 */
+    private hasEnterOnStopEvent;
+    /** 需要检测 cursor 的物体 Map<obj, cursorStyle> */
+    private cursorObjects;
+    private cursorListenerAdded;
+    /** 用于检测鼠标停止移动 */
+    private moveStopTimer;
+    private moveStopDelay;
+    private lastMoveEvent;
+    private lastMoveActiveObjects;
+    private lastMoveRealActiveObject;
+    /** 已经触发过 enterOnStop 的物体，用于防止重复触发 */
+    private triggeredEnterOnStopObjects;
+    private domElement;
+    private disposed;
+    private containerListeners;
+    private listen;
+    private unlisten;
+    private clearInteractionState;
+    constructor(pencil: Pencil);
+    private waitForClick;
+    private addPickListener;
+    private processIntersection;
+    private processObjectHierarchy;
+    private handleLeaveEvents;
+    private handleDownOutside;
+    /** 处理鼠标停止移动事件 */
+    private handleMoveStop;
+    /** 触发 enterOnStop 事件 */
+    private triggerEnterOnStop;
+    /** 重置鼠标样式 */
+    private resetCursor;
+    /** 添加 cursor 检测监听器 */
+    private addCursorListener;
+    /**
+     * 启用物体的 cursor 检测
+     * @param obj 要检测的 BaseObject
+     * @param cursor 鼠标样式，默认 'pointer'
+     */
+    enableCursor(obj: BaseObject, cursor?: string): void;
+    /**
+     * 禁用物体的 cursor 检测
+     * @param obj 要移除的 BaseObject
+     */
+    disableCursor(obj: BaseObject): void;
+    handlePick(objArr: PickFunctionsItem['objArr'], t: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): number;
+    removePick(key: number): void;
+    handlePickNode(objArr: PickFunctionsItem['objArr'], type: PickFunctionsItem['type'], callback: PickFunctionsItem['cb']): number;
+    removePickNode(key: number): void;
+    dispose(): void;
+}
+
+declare type PickFunctionsItem = {
+    objArr: BaseObject[] | (() => BaseObject[]);
+    type: 'move' | 'enter' | 'leave' | 'down' | 'click' | 'downOutside' | 'clickOutside' | 'enterOnStop';
+    cb: (data: {
+        baseObject: BaseObject;
+        realBaseObject?: BaseObject;
+        mouseEvent: MouseEvent;
+        intersectionIndex?: number;
+        sp?: () => void;
+    }) => void;
+};
+
 export declare interface PlanarMap {
     object3d: Object3D;
     options: {
@@ -1486,7 +4427,7 @@ export declare type PlaneMap = PlaneMap_2;
 
 declare class PlaneMap_2 extends GroupObject {
     objectType: string;
-    options: Required<Omit<Options, 'bbox' | 'extrudeLineGeojson' | 'uuid'>> & Pick<Options, 'bbox' | 'extrudeLineGeojson' | 'uuid'>;
+    options: Required<Omit<Options_14, 'bbox' | 'extrudeLineGeojson' | 'uuid'>> & Pick<Options_14, 'bbox' | 'extrudeLineGeojson' | 'uuid'>;
     isActive: boolean;
     groupArr: GroupObject[];
     areaArr: ExtrudePolygonObject[];
@@ -1496,7 +4437,7 @@ declare class PlaneMap_2 extends GroupObject {
     splitPolygons: number;
     private standaloneHideMaterial?;
     private getHideMaterial;
-    constructor(options: Options);
+    constructor(options: Options_14);
     create(): Promise<void>;
     private markGeneratedObjects;
     private ensureExtrudeLineMaterials;
@@ -1507,7 +4448,7 @@ declare class PlaneMap_2 extends GroupObject {
     mergeAreaSide(): Promise<void>;
     unmergeAreaSide(): Promise<void>;
     addArea(geojson: GeoJSON_2, options: {
-        material: THREE.Material | THREE.Material[];
+        material: _THREE.Material | _THREE.Material[];
         bbox?: number[];
         areaGroup?: boolean;
         hasSide?: boolean;
@@ -1569,21 +4510,53 @@ export declare function planPlacement(model: Object3D, map: PlanarMap, anchor: M
 
 declare class Point extends BaseObject {
     objectType: string;
-    options: Options_4;
-    constructor(options: Options_4);
-    get material(): THREE.MeshBasicMaterial | THREE.SpriteMaterial;
-    getMaterial(): THREE.MeshBasicMaterial | THREE.SpriteMaterial;
+    options: Options_17;
+    constructor(options: Options_17);
+    get material(): _THREE.MeshBasicMaterial | _THREE.SpriteMaterial;
+    getMaterial(): _THREE.MeshBasicMaterial | _THREE.SpriteMaterial;
     create(): Promise<void>;
     scaleValue: number;
     setScale(n: number): void;
 }
 
+declare class PointerEvent_2 {
+    lead: Lead_2;
+    private pointerSubscriptions;
+    protected createPointerBinding(type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): () => void;
+    onPointerEvent(type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): () => void;
+    onClick(cb: PickFunctionsItem['cb']): () => void;
+    onPointerEnter(cb: PickFunctionsItem['cb']): () => void;
+    onPointerEnterOnStop(cb: PickFunctionsItem['cb']): () => void;
+    onPointerLeave(cb: PickFunctionsItem['cb']): () => void;
+    onPointerMove(cb: PickFunctionsItem['cb']): () => void;
+    onPointerDown(cb: PickFunctionsItem['cb']): () => void;
+    onPointerDownOutside(cb: PickFunctionsItem['cb']): () => void;
+    onClickOutside(cb: PickFunctionsItem['cb']): () => void;
+    dispose(): void;
+}
+
+declare interface PointerInput {
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    deltaX: number;
+    deltaY: number;
+    mouseButton: MOUSE_BUTTON | null;
+}
+
 declare class PointLight extends PointLightObject {
     constructor(...options: ConstructorParameters<typeof PointLightObject>);
     update(delta: number, elapsed: number): void;
     render(): void;
 }
 
+declare class PointLightObject extends BaseObject<PointLight_2> {
+    objectType: string;
+    constructor(lightOrColor?: PointLight_2 | string | number, intensity?: number, distance?: number, decay?: number);
+}
+
+declare type PointsInput_2 = Vector3[] | Vector2_2[] | number[][] | number[];
+
 export declare interface PrefabAsset {
     id: string;
     name: string;
@@ -1607,6 +4580,21 @@ export declare function prepareGeometryBinding(before: VisSceneDocument, sceneId
 /** Change one binding; a conflicting borrowed UUID must not overwrite its other users. */
 export declare function prepareGeometryEdit(before: VisSceneDocument, sceneId: string, uuid: string, input: GeometryDefinition | null): VisSceneDocument;
 
+declare const projectionObj: {
+    mercator: typeof geoMercator;
+    equirectangular: typeof geoEquirectangular;
+    winkel3: typeof geoWinkel3;
+};
+
+declare type ProjectionOptions = {
+    center: [number, number];
+    scale: number;
+    projectionType?: keyof typeof projectionObj;
+    translate?: [number, number];
+    precision?: number;
+    rotate?: [number, number];
+};
+
 /** Uses the same projection and Y sign as PlaneMap geometry, then its world matrix. */
 export declare function projectLocation(map: PlanarMap, anchor: MapAnchor, mapCRS: string): {
     local: Vector3;
@@ -1623,10 +4611,20 @@ export declare function promoteMaterialToProject<T extends VisSceneDocument>(doc
 declare class RectAreaLight extends RectAreaLightObject {
 }
 
+declare class RectAreaLightObject extends BaseObject<RectAreaLight_2> {
+    objectType: string;
+    static rectAreaLightUniformsLibInit: boolean;
+    constructor(colorOrLight?: RectAreaLight_2 | string | number, intensity?: number, width?: number, height?: number);
+}
+
+declare type Ref = {
+    value: number;
+};
+
 export declare interface RegionTextureRule {
     /** 材质 UUID，或显式材质角色，例如 plane#topMat。 */
     material: string;
-    /** THREE.Material 上的纹理属性，例如 map、emissiveMap。 */
+    /** THREE.Material 上的纹理属性，例如 map、emissiveMap；未匹配或加载失败时清空此槽位。 */
     property: string;
     /** 资源地址模板，支持 {adcode} 和 {level} 占位符。 */
     url?: string;
@@ -1634,7 +4632,7 @@ export declare interface RegionTextureRule {
     sources?: Record<string, string>;
     /** 复用同一材质上另一个纹理槽位的图片。 */
     copyFrom?: string;
-    /** 仅在指定地图展示层级应用。 */
+    /** 资源生效层级；没有匹配规则的层级清空对应槽位。 */
     levels?: string[];
 }
 
@@ -1672,7 +4670,8 @@ export declare const remapSceneMaterialReferencesCopy: <T>(scene: T, previous: s
 
 export declare const remapSceneObjectReferencesCopy: <T>(scene: T, previous: string, next: string) => T;
 
-export { remapSnapshotAnimationTracks }
+/** Keep native clips and authored Model clips bound to the same copied nodes. */
+export declare function remapSnapshotAnimationTracks(json: any, ids: ReadonlyMap<string, string>, roots?: readonly any[]): void;
 
 /** Copy an authored snapshot with fresh native and authored reference identities. */
 export declare function remapSnapshotIdentity(input: any, rootUuid?: string, sharedResourceIds?: ReadonlyMap<string, string>): any;
@@ -1686,6 +4685,46 @@ export declare function removeProjectMaterial<T extends VisSceneDocument>(docume
 
 export declare function removeSceneDocument(before: VisSceneDocument, sceneId: string): VisSceneDocument;
 
+declare class RendererController {
+    renderer: WebGPURenderer;
+    readonly ready: Promise<void>;
+    initialized: boolean;
+    private disposed;
+    private readonly pointSprites;
+    options: Options_4;
+    private displayScaleObserver?;
+    constructor(options: Options_4);
+    observeDisplayScale(container: HTMLElement): void;
+    setSize(width: number, height: number): void;
+    setPixelRatio(ratio: number): void;
+    render(scene: Scene_2, camera: Camera_2): void;
+    setViewport(op: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        scissor?: boolean;
+        scissorTest?: boolean;
+    }): void;
+    dispose(): void;
+}
+
+declare interface RendererParams {
+    antialias: boolean;
+    devicePixelRatio: number;
+    powerPreference: 'high-performance' | 'low-power' | 'default';
+    toneMappingExposure: number;
+    alpha: boolean;
+    outputColorSpace: (typeof ColorSpace)[keyof typeof ColorSpace];
+    logarithmicDepthBuffer: boolean;
+    preserveDrawingBuffer: boolean;
+    stencil: boolean;
+    depth: boolean;
+    reversedDepthBuffer: boolean;
+    /** Use the WebGL 2 backend of WebGPURenderer, primarily for compatibility testing. */
+    forceWebGL?: boolean;
+}
+
 export declare function replaceMaterialAssetDocument(document: VisSceneDocument, asset: MaterialAsset): VisSceneDocument;
 
 export declare const RESOURCE_SOURCE = "_resourceSource";
@@ -1693,6 +4732,149 @@ export declare const RESOURCE_SOURCE = "_resourceSource";
 /** Stable UUID for an asset's resource instance; content revisions do not change identity. */
 export declare function resourceInstanceUuid(assetId: string, kind: string, sourceUuid: string): string;
 
+declare type ResourceKind = StructureResourceKind;
+
+declare const resourceKinds: readonly ["geometries", "materials", "textures", "images", "skeletons", "animations"];
+
+declare interface ResourceLease<T extends object = object> {
+    readonly resource: T;
+    readonly released: boolean;
+    release(): void;
+}
+
+/** Ownership belongs to each resource, independently of its users and dependencies. */
+declare type ResourceOwnership = 'owned' | 'borrowed';
+
+/**
+ * Leases are roots in a resource graph. Unmarked resources are SDK-owned;
+ * external resources must be marked borrowed before they enter the graph.
+ * Reachability rather than recursive reference counts also handles cyclic data.
+ */
+declare class ResourceRegistry {
+    private entries;
+    private shared;
+    private disposedResources;
+    private ownership;
+    private attachmentOwners;
+    private extraDependencies;
+    private dependencyLeases;
+    private closed;
+    private syncing;
+    private batchDepth;
+    private syncPending;
+    private disposedCount;
+    private creationFrames;
+    private pendingMutations;
+    get isDisposed(): boolean;
+    wasDisposed(resource: object): boolean;
+    createScope(owner?: unknown): ResourceScope;
+    getOwnership(resource: object): ResourceOwnership | undefined;
+    /**
+     * Synchronously allocate or clone an SDK resource. The factory must return a
+     * new allocation. Use this boundary when nested allocations need rollback;
+     * ordinary resources become owned when bound, without a factory.
+     */
+    create<T extends object>(factory: () => T): T;
+    /**
+     * Coalesce collection requests during synchronous mutations, including failure.
+     * Nested batches share the outer boundary; returning a promise never extends
+     * the batch across its asynchronous work. This is not a rollback transaction.
+     */
+    batch<T>(mutate: () => T): T;
+    /** Explicit transfer. Recursive adoption is only for a newly allocated asset graph. */
+    adopt<T extends object>(resource: T, options?: {
+        recursive?: boolean;
+        preserveExisting?: boolean;
+    }): T;
+    /** Leave cleanup to the caller. Recursive classification preserves known dependencies. */
+    borrow<T extends object>(resource: T, options?: {
+        recursive?: boolean;
+    }): T;
+    /**
+     * Hand a complete live graph back to its caller before closing a temporary
+     * allocation scope. Unlike borrow(), this also transfers already-owned
+     * dependencies. Existing leases are unchanged; unreachable allocations still
+     * belong to this registry and are collected normally.
+     */
+    releaseOwnership<T extends object>(resource: T): T;
+    private setOwnership;
+    /** A render target owns its attachments; attachment users keep the target alive. */
+    registerAttachment(attachment: object, owner: object): void;
+    /** Dependencies hidden in render closures still participate in lease reachability. */
+    registerDependencies(resource: object, dependencies: Iterable<object>): void;
+    /** Add independently owned edges without replacing another adapter's dependencies. */
+    addDependencies(resource: object, dependencies: Iterable<object>): () => void;
+    /** Hold a resource graph without changing ownership of any resource. */
+    retain<T extends object>(resource: T): ResourceLease<T>;
+    /** Capture one synchronous snapshot of multiple roots, with independent leases.
+     * Shared descendants are visited once here; later retain calls capture anew. */
+    retainMany<T extends object>(resources: readonly T[]): ResourceLease<T>[];
+    /**
+     * Protect a completed allocation immediately, then commit synchronous work in
+     * the next microtask's batch. Network/other asynchronous work belongs before
+     * this call. Promises settle only after collection; an unrelated release or
+     * shutdown still runs normally while the mutation is queued.
+     */
+    enqueueResourceMutation<T>(resource: object, mutate: () => T): Promise<T>;
+    private flushMutations;
+    private retainInternal;
+    private ensureEntry;
+    private captureDependencies;
+    private captureDeferredDependencies;
+    getShared<T extends object = object>(key: string): T | undefined;
+    /** Explicit identity changes invalidate cached definitions of that resource. */
+    invalidateShared(resource: object): void;
+    share<T extends object>(key: string, resource: T): T;
+    private dependencies;
+    sync(_resource?: object): void;
+    private collectUnused;
+    /** Free unbound SDK allocations; explicitly borrowed resources remain untouched. */
+    disposeUnused(resource: any): void;
+    getStats(): {
+        resources: number;
+        materials: number;
+        textures: number;
+        sources: number;
+        leases: number;
+        owned: number;
+        borrowed: number;
+        disposed: number;
+    };
+    dispose(): void;
+}
+
+/** A group of idempotent leases, suitable for scenes, loaders and previews. */
+declare class ResourceScope {
+    private leases;
+    private closed;
+    readonly registry: ResourceRegistry;
+    readonly owner: unknown;
+    constructor(registry: ResourceRegistry, owner?: unknown);
+    /** Allocate an SDK resource and hold it until this operation releases its scope. */
+    create<T extends object>(factory: () => T): T;
+    retain<T extends object>(resource: T): ResourceLease<T>;
+    dispose(): void;
+}
+
+declare interface RestoreBaseObjectOptions {
+    /** Transfer an exclusively owned snapshot between packages; restoration may mutate it. */
+    consumeInput?: boolean;
+    /** The caller must validate equality with the serialized resource definitions. */
+    reuseResources?: ReusableObjectResources;
+    /** Bypass unvalidated registry caches; only reuseResources may supply existing instances. */
+    strictResourceReuse?: boolean;
+}
+
+/**
+ * Live resources whose serialized definitions the caller has already verified.
+ * Reuse is explicit: equal UUIDs alone do not establish equal definitions.
+ */
+declare interface ReusableObjectResources {
+    geometries?: ReadonlyMap<string, BufferGeometry>;
+    materials?: ReadonlyMap<string, Material>;
+    textures?: ReadonlyMap<string, Texture>;
+}
+
 declare class Ring extends MeshObject {
     objectType: string;
     create(): void;
@@ -1700,8 +4882,8 @@ declare class Ring extends MeshObject {
 
 declare class Road extends GroupObject {
     objectType: string;
-    options: Options_7;
-    constructor(options: Options_7);
+    options: Options_20;
+    constructor(options: Options_20);
     linePrimary: LineObject[];
     lineSecondary: LineObject[];
     create(): Promise<void>;
@@ -1736,6 +4918,14 @@ export declare interface SceneBackInteraction {
     };
 }
 
+declare interface SceneCaptureOptions {
+    /** Physical output pixels. Defaults to the active content viewport. */
+    width?: number;
+    height?: number;
+    pixelRatio?: number;
+    maxDimension?: number;
+}
+
 /** Scene membership/options delta. Existing authored graphs must use structure patches. */
 export declare interface SceneCollectionTransaction {
     scenes: readonly SceneViewportDocument[];
@@ -2020,6 +5210,16 @@ export declare interface SceneObjectPropertyPatch {
     unset?: readonly string[];
 }
 
+declare class ScenePages extends OrigonPages<Scene> {
+    get scene(): Scene< Object3DEventMap>;
+    addScene(sceneParams?: SceneParams, index?: number): Scene< Object3DEventMap>;
+    setPageActive(index: number): void;
+}
+
+declare interface SceneParams {
+    background: Scene['background'];
+}
+
 declare type ScenePropertyField = typeof scenePropertyFields[number];
 
 export declare const scenePropertyFields: readonly ["color", "groundColor", "intensity", "distance", "decay", "angle", "penumbra", "width", "height", "castShadow", "receiveShadow", "frustumCulled", "renderOrder", "up", "center", "shadow", "near", "far", "fov", "aspect", "zoom", "left", "right", "top", "bottom", "focus", "filmGauge", "filmOffset", "view", "backgroundBlurriness", "backgroundIntensity", "environmentIntensity", "backgroundRotation", "environmentRotation"];
@@ -2030,6 +5230,101 @@ export declare interface SceneResourceCandidate {
     root?: any;
 }
 
+declare class SceneResources_2 {
+    pencil: Pencil;
+    private materials;
+    private transientKeys;
+    private lockedKeys;
+    private materialBaseObjectMap;
+    readonly resources: ResourceRegistry;
+    private aliasLeases;
+    private objectLeases;
+    private sceneLeases;
+    private geometryLeases;
+    readonly emptyGeometryObjects: Set<Object3D< Object3DEventMap>>;
+    private emptyGeometryOwners;
+    private nativeObjectLeases;
+    private proxiedObjects;
+    readonly optionDependencies: OptionMaterialDependencies;
+    private preparedObjects;
+    constructor(pencil: Pencil);
+    prepareOptionMaterials(options: any, scope: ResourceScope): void;
+    /** Temporary preparation protects asynchronous construction, never idle options. */
+    prepareObjectCreate(object: BaseObject): void;
+    add(material: Material, ops?: MaterialRegistrationOptions): void;
+    /** An explicit key becomes the native material UUID. */
+    add(key: string, material: Material, ops?: MaterialRegistrationOptions): void;
+    /** Change the native UUID atomically in every catalog sharing this material. */
+    setKey(reference: string, key: string): void;
+    private reindexMaterial;
+    getAlias(key: string): MaterialAlias_2 | undefined;
+    getAliases(): readonly MaterialAlias_2[];
+    setAliasMaterial(key: string, material: Material, ops?: MaterialRegistrationOptions): void;
+    get(key: string): Material | undefined;
+    getByName(name: string): Material | undefined;
+    getKey(material: Material): string | undefined;
+    getKeyByName(name: string): string | undefined;
+    addMultiple(key: string, materialMap: Record<string, Material | null>): void;
+    getMultiple(key: string): Record<string, Material> | null;
+    copy(sourceKey: string, destinationKey: string, ops?: {
+        name?: string;
+    }): Material | null;
+    copyMultiple(sourceKey: string, destinationKey: string): Record<string, Material>;
+    retainSceneResources(scene: any): void;
+    disposeResource(resource?: object | object[]): void;
+    disposeMaterial(material?: Material | Material[]): void;
+    remove(key: string): void;
+    private detachEntry;
+    private unregisterMaterial;
+    removeByMaterial(material: Material): void;
+    proxyBaseObject(object: BaseObject): void;
+    private applyColorSpaceToMaterials;
+    private material2array;
+    /** Native setters can outlive their wrapper. Retire new allocations without
+     * reacquiring leases; explicitly borrowed assignments stay caller-owned. */
+    private cleanupDisposedObject;
+    private syncObjectGeometry;
+    addBaseObjectMap(object: BaseObject): void;
+    /** Acquire a newly registered tree in one snapshot before slot observers run. */
+    retainNativeObjects(objects: readonly BaseObject[]): void;
+    /** Internal: Transfer a prepared native lease without changing slot observers. */
+    bindNativeObjectLease(object: BaseObject, lease: ResourceLease): void;
+    private updateBaseObjectMap;
+    rmBaseObjectMap(object: BaseObject, targetMaterial?: Material | Material[]): void;
+    private releaseBaseObjectMap;
+    getBaseObjectMap(material: Material): Set<BaseObject<Object3D< Object3DEventMap>>>;
+    setLocked(key: string, locked?: boolean): boolean;
+    lock(key: string): boolean;
+    unlock(key: string): boolean;
+    isLocked(key: string): boolean;
+    isMaterialUsed(key: string): boolean;
+    shouldExportAlias(key: string, includeUnusedUnlockedMaterials?: boolean): boolean;
+    syncChangeMaterial(oldMaterial: Material, material: Material): void;
+    dispose(): void;
+}
+
+declare class SceneResourcesPages extends OrigonPages<SceneResources_2> {
+    options: Options_12;
+    get sceneResources(): SceneResources_2;
+    constructor(options: Options_12);
+    addSceneResources(_: any, index?: number): SceneResources_2;
+    removePage(index: number): void;
+}
+
+/** Coordinates snapshot export and restoration against the current Lead runtime. */
+declare class SceneSerializer {
+    private lead;
+    constructor(lead: Lead_2);
+    exportCompressBaseObject(root: BaseObject, options?: ExportBaseObjectOptions): Promise<ArrayBuffer>;
+    exportBaseObject(root: BaseObject, options?: ExportBaseObjectOptions): SceneSnapshot;
+    restoreBaseObject(target: BaseObject, data: string | ArrayBuffer | Object3DJSON, registry?: Record<string, new (...args: any[]) => any>, roomEnvMap?: any, createIfNeeded?: boolean, signal?: AbortSignal, options?: RestoreBaseObjectOptions): Promise<BaseObject<Object3D< Object3DEventMap>>>;
+    private _graftObject3d;
+}
+
+declare type SceneSnapshot = Object3DJSON & {
+    materialAliases?: Record<string, SerializedMaterialAlias>;
+};
+
 export declare type SceneStructureGraphKey = 'materialAliases' | 'shapes' | '_sharedOptionsPool' | '_texDataPool';
 
 /** Metadata is part of an owned structure transaction, never a scalar runtime patch. */
@@ -2156,6 +5451,32 @@ export declare interface SceneViewportPatch {
 
 export declare function selectSceneDocument(document: VisSceneDocument, sceneId: string): VisSceneDocument;
 
+declare type SerializedClip = ReturnType<(typeof _THREE.AnimationClip)['toJSON']>;
+
+declare interface SerializedMaterialAlias {
+    materialUuid: string;
+    locked: boolean;
+}
+
+declare type singleTouchAction =
+| typeof ACTION.TOUCH_ROTATE
+| typeof ACTION.TOUCH_TRUCK
+| typeof ACTION.TOUCH_SCREEN_PAN
+| typeof ACTION.TOUCH_OFFSET
+| typeof ACTION.DOLLY
+| typeof ACTION.ZOOM
+| typeof ACTION.NONE;
+
+declare const sinusoidalInOut: ({ owner, onUpdate, onComplete, onCancel, backwards, }?: TweenOptions) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<void>;
+    stop: () => void;
+};
+
 declare class Sphere extends MeshObject {
     radius: number;
     options: any;
@@ -2164,10 +5485,30 @@ declare class Sphere extends MeshObject {
     create(): void;
 }
 
+/** Exact radial lift above the short great circle, expressed in object-local space. */
+declare class SphereArcCurve extends _THREE.Curve<_THREE.Vector3> {
+    readonly type = "SphereArcCurve";
+    readonly data: ArcSpherePath;
+    readonly matrix: _THREE.Matrix4;
+    constructor(path: ArcSpherePath);
+    get v0(): _THREE.Vector3;
+    get v3(): _THREE.Vector3;
+    getPoint(t: number, target?: _THREE.Vector3): _THREE.Vector3;
+    getTangent(t: number, target?: _THREE.Vector3): _THREE.Vector3;
+    clone(): this;
+    copy(source: _THREE.Curve<_THREE.Vector3>): this;
+    toJSON(): SphereArcCurveJSON;
+    fromJSON(json: _THREE.CurveJSON): this;
+}
+
+declare interface SphereArcCurveJSON extends _THREE.CurveJSON {
+    spherePath: ArcSpherePath;
+}
+
 declare class SphereShadow extends MeshObject {
     objectType: string;
-    options: Required<Options_3>;
-    constructor(options: Options_3);
+    options: Required<Options_16>;
+    constructor(options: Options_16);
     create(): Promise<void>;
     rebuildFromScene(): void;
 }
@@ -2197,15 +5538,143 @@ declare class SpotLight extends SpotLightObject {
     render(): void;
 }
 
-declare class Sprite extends SpriteObject {
+declare class SpotLightObject extends BaseObject<SpotLight_2> {
+    objectType: string;
+    constructor(lightOrColor?: SpotLight_2 | string | number, intensity?: number, distance?: number, angle?: number, penumbra?: number, decay?: number);
+    render(): void;
+    dispose(): void;
+}
+
+declare class Sprite_2 extends SpriteObject {
     objectType: string;
     create(): void;
     setDesiredPixelSize(size: number): void;
 }
 
+declare class SpriteObject<M extends SpriteMaterial = SpriteMaterial> extends BaseObject<Sprite> {
+    objectType: string;
+    constructor(materialOrSprite?: M | Sprite);
+}
+
+declare interface SSAOParams {
+    kernelRadius: number;
+    minDistance: number;
+    maxDistance: number;
+}
+
+declare class Stats {
+    dom: HTMLDivElement;
+    mode: number;
+    horizontal: boolean;
+    minimal: boolean;
+    trackGPU: boolean;
+    trackHz: boolean;
+    trackFPS: boolean;
+    trackCPT: boolean;
+    samplesLog: number;
+    samplesGraph: number;
+    precision: number;
+    logsPerSecond: number;
+    graphsPerSecond: number;
+    gl: WebGL2RenderingContext | null;
+    ext: any | null;
+    info?: InfoData;
+    private activeQuery;
+    private gpuQueries;
+    private threeRendererPatched;
+    private beginTime;
+    private prevCpuTime;
+    private frameTimes;
+    private renderCount;
+    private totalCpuDuration;
+    private totalGpuDuration;
+    private totalGpuDurationCompute;
+    private _panelId;
+    private fpsPanel;
+    private msPanel;
+    private gpuPanel;
+    private gpuPanelCompute;
+    private vsyncPanel;
+    averageFps: AverageData;
+    averageCpu: AverageData;
+    averageGpu: AverageData;
+    averageGpuCompute: AverageData;
+    private updateCounter;
+    private prevGraphTime;
+    private lastMin;
+    private lastMax;
+    private lastValue;
+    private prevTextTime;
+    private readonly VSYNC_RATES;
+    private detectedVSync;
+    private frameTimeHistory;
+    private readonly HISTORY_SIZE;
+    private readonly VSYNC_THRESHOLD;
+    private lastFrameTime;
+    static Panel: typeof Panel;
+    constructor({ trackGPU, trackCPT, trackHz, trackFPS, logsPerSecond, graphsPerSecond, samplesLog, samplesGraph, precision, minimal, horizontal, mode }?: StatsOptions);
+    private initializeDOM;
+    private setupEventListeners;
+    private handleClick;
+    private handleResize;
+    init(canvasOrGL: WebGL2RenderingContext | HTMLCanvasElement | OffscreenCanvas | any): Promise<void>;
+    private handleThreeRenderer;
+    private handleWebGPURenderer;
+    private initializeWebGPUPanels;
+    private initializeWebGL;
+    private initializeGPUTracking;
+    begin(): void;
+    end(): void;
+    update(): void;
+    private processWebGPUTimestamps;
+    private resetCounters;
+    resizePanel(panel: Panel): void;
+    addPanel(panel: Panel): Panel;
+    showPanel(id: number): void;
+    processGpuQueries(): void;
+    private detectVSync;
+    endInternal(): number;
+    private updatePanelComponents;
+    private beginProfiling;
+    private endProfiling;
+    updatePanel(panel: {
+        update: any;
+        updateGraph: any;
+        name: string;
+    } | null, averageArray: {
+        logs: number[];
+        graph: number[];
+    }, precision?: number): void;
+    private updateAverages;
+    addToAverage(value: number, averageArray: {
+        logs: any;
+        graph: any;
+    }): void;
+    get domElement(): HTMLDivElement;
+    patchThreeWebGPU(renderer: any): void;
+    patchThreeRenderer(renderer: any): void;
+}
+
+declare interface StatsOptions {
+    trackGPU?: boolean;
+    trackCPT?: boolean;
+    trackHz?: boolean;
+    trackFPS?: boolean;
+    logsPerSecond?: number;
+    graphsPerSecond?: number;
+    samplesLog?: number;
+    samplesGraph?: number;
+    precision?: number;
+    minimal?: boolean;
+    horizontal?: boolean;
+    mode?: number;
+}
+
 export declare function stripMaterialAssetBinding<T extends Record<string, any>>(material: T): T;
 
-export { StructureResources }
+declare type StructureResourceKind = typeof resourceKinds[number];
+
+export declare type StructureResources = Record<ResourceKind, Record<string, any>[]>;
 
 export declare interface SwitchSceneOptions {
     /** 返回历史时不再记录当前场景。 */
@@ -2216,13 +5685,113 @@ export declare interface SwitchSceneOptions {
 
 export { THREE }
 
+declare interface THREESubset {
+    Vector2: typeof _THREE.Vector2;
+    Vector3: typeof _THREE.Vector3;
+    Vector4: typeof _THREE.Vector4;
+    Quaternion: typeof _THREE.Quaternion;
+    Matrix4: typeof _THREE.Matrix4;
+    Spherical: typeof _THREE.Spherical;
+    Box3: typeof _THREE.Box3;
+    Sphere: typeof _THREE.Sphere;
+    Raycaster: typeof _THREE.Raycaster;
+    [key: string]: any;
+}
+
+declare const timeOut: (ms: number) => Promise<any>;
+
+declare interface Touches {
+    one: singleTouchAction;
+    two: multiTouchAction;
+    three: multiTouchAction;
+}
+
+declare class TransformControlsController {
+    controls: TransformControls;
+    private readonly neutralCamera;
+    private helper?;
+    private viewScene?;
+    private viewport?;
+    get detach(): () => TransformControls;
+    get attach(): (object: Object3D_2) => TransformControls;
+    event: EventEmitter;
+    constructor(options: Options_7);
+    setViewport(viewport: Viewport): void;
+    bindActiveView(camera: Camera_2 | undefined, scene: Scene_2 | undefined, viewScene?: Scene_2< Object3DEventMap> | undefined): void;
+    private releaseRaycastCamera;
+    private getBoundingClientRect;
+    addEvent(): void;
+    dispose(): void;
+}
+
+declare class TubeObject extends MeshObject {
+    objectType: string;
+    options: TubeOptions;
+    constructor(options: TubeOptions);
+    create(): void;
+}
+
+declare interface TubeOptions {
+    path?: _THREE.Curve<_THREE.Vector3>;
+    radius?: number;
+    multiplyScalar?: number;
+    /** Compact saved inputs for an Arc's derived picking geometry. */
+    arcControlPoints?: number[][];
+    arcSpherePath?: ArcSpherePath;
+}
+
 export { TWEEN }
 
 export declare type Tween<T extends Record<string, any>> = Tween_2<T>;
 
+declare interface TweenOptions {
+    owner?: Pick<Pencil, 'animations'>;
+    onUpdate?: (value: number) => void;
+    onComplete?: () => void;
+    onCancel?: () => void;
+    backwards?: boolean;
+}
+
+declare type TypeEXR = ValuesOf<(typeof KNOWN_ASSET_TYPES)['exr']>;
+
+declare type TypeGLTF = ValuesOf<(typeof KNOWN_ASSET_TYPES)['gltf']>;
+
+declare type TypeGzipJSON = ValuesOf<(typeof KNOWN_ASSET_TYPES)['gzipJson']>;
+
+declare type TypeImage = ValuesOf<(typeof KNOWN_ASSET_TYPES)['images']>;
+
+declare type TypeJSON = ValuesOf<(typeof KNOWN_ASSET_TYPES)['json']>;
+
+declare type TypeLottie = ValuesOf<(typeof KNOWN_ASSET_TYPES)['lottie']>;
+
+declare type TypeMedia = ValuesOf<(typeof KNOWN_ASSET_TYPES)['media']>;
+
 export declare function updateProjectMaterial<T extends VisSceneDocument>(document: T, assetId: string, patch: Partial<Pick<MaterialAsset, 'name' | 'material' | 'locked'>>): T;
 
-export declare const VERSION = "0.33.7";
+declare class UseMaterial extends PointerEvent_2 {
+    pencil: Pencil;
+    lead: Lead_2;
+    sceneResources: SceneResources_2;
+    userData: Record<string, any>;
+    object3d: Object3D;
+    cloneMaterial(): Material< MaterialEventMap> | Material< MaterialEventMap>[] | undefined;
+    useSceneMaterialById(id: string, slot?: number): void;
+    useSceneMaterialByName(name: string, slot?: number): void;
+    dispose(): void;
+}
+
+declare type ValuesOf<T extends readonly any[]> = T[number];
+
+export declare const VERSION = "0.33.9";
+
+declare interface Viewport {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    fullWidth: number;
+    fullHeight: number;
+}
 
 /** Enumerate authored reference fields only; never inspect arbitrary userdata or resource payloads. */
 export declare function visitSceneIdentityReferences(scene: any, objectIdentity: boolean, visit: (path: IdentityPath, value: any, track?: boolean, key?: boolean) => void): void;
@@ -2260,7 +5829,7 @@ export declare interface VisSceneManifest {
     s?: string;
 }
 
-declare class Water extends Mesh<BufferGeometry, ShaderMaterial> {
+declare class Water extends Mesh_2<BufferGeometry, NodeMaterial & { uniforms: Record<string, IUniform> }> {
     static WaterShader: WaterShader;
     isWater: true;
     constructor(geometry: BufferGeometry, options: WaterOptions);
@@ -2273,7 +5842,7 @@ declare interface WaterOptions {
     textureWidth?: number;
     textureHeight?: number;
     clipBias?: number;
-    flowDirection?: Vector2;
+    flowDirection?: Vector2_2;
     flowSpeed?: number;
     reflectivity?: number;
     scale?: number;
@@ -2286,8 +5855,9 @@ declare interface WaterOptions {
 declare interface WaterShader {
     name: string;
     uniforms: Record<string, IUniform>;
-    vertexShader: string;
-    fragmentShader: string;
+    colorNode?: Node_2 | ((uniforms: Record<string, IUniform>, defaultColor: Node_2) => Node_2);
 }
 
+declare type WidthCallback = (p: number) => number;
+
 export { }