@treasuryspatial/viewer-kit 0.2.44 → 0.2.50

package/dist/autoGenerate.d.ts

@@ -4,6 +4,7 @@ export type AutoGenerateGateOptions = {
     loading?: boolean;
     isGhTool?: boolean;
     isMeshTool?: boolean;
+    isUploadSource?: boolean;
     enabled?: boolean;
 };
 export type AutoGenerateGate = {

package/dist/autoGenerate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoGenerate.d.ts","sourceRoot":"","sources":["../src/autoGenerate.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,kBAAkB,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAClE,aAAa,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACxC,YAAY,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC;CACnD,CAAC;AAEF,eAAO,MAAM,sBAAsB,QAAO,gBA2CzC,CAAC"}
+{"version":3,"file":"autoGenerate.d.ts","sourceRoot":"","sources":["../src/autoGenerate.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,kBAAkB,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAClE,aAAa,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACxC,YAAY,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC;CACnD,CAAC;AAEF,eAAO,MAAM,sBAAsB,QAAO,gBAkDzC,CAAC"}

package/dist/autoGenerate.js

@@ -1,8 +1,9 @@
 export const createAutoGenerateGate = () => {
     const generated = new Set();
+    const pending = new Set();
     const normalizeId = (toolId) => (toolId ?? '').trim();
     return {
-        shouldAutoGenerate: ({ toolId, toolsStatus, loading, isGhTool, isMeshTool, enabled = true, }) => {
+        shouldAutoGenerate: ({ toolId, toolsStatus, loading, isGhTool, isMeshTool, isUploadSource, enabled = true, }) => {
             if (!enabled)
                 return false;
             const resolvedId = normalizeId(toolId);
@@ -10,27 +11,34 @@ export const createAutoGenerateGate = () => {
                 return false;
             if (loading)
                 return false;
+            if (isUploadSource)
+                return false;
             if (isGhTool || isMeshTool)
                 return false;
             if (toolsStatus && toolsStatus !== 'ready')
                 return false;
             if (generated.has(resolvedId))
                 return false;
-            generated.add(resolvedId);
+            if (pending.has(resolvedId))
+                return false;
+            pending.add(resolvedId);
             return true;
         },
         markGenerated: (toolId) => {
             const resolvedId = normalizeId(toolId);
             if (!resolvedId)
                 return;
+            pending.delete(resolvedId);
             generated.add(resolvedId);
         },
         reset: (toolId) => {
             const resolvedId = normalizeId(toolId);
             if (!resolvedId) {
+                pending.clear();
                 generated.clear();
                 return;
             }
+            pending.delete(resolvedId);
             generated.delete(resolvedId);
         },
         hasGenerated: (toolId) => {

package/dist/camera.d.ts

@@ -8,6 +8,7 @@ export type CameraFrameConfig = {
 export type CameraNormalizationConfig = {
     recenter?: boolean;
     floorToZero?: boolean;
+    anchor?: THREE.Vector3;
     normalizePlan?: {
         target?: number;
         maxScale?: number;

package/dist/camera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,UAAU,CAAC;AAEjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;IACtB,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;CACvB,CAAC;AAKF,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,KAAK,CAAC,QAAQ,EACtB,SAAS,yBAAyB,KACjC,yBAuDF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,KAAK,CAAC,IAAI,EAClB,YAAY,MAAM,EAClB,SAAS,iBAAiB,KACzB;IAAE,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CAoBlD,CAAC"}
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,UAAU,CAAC;AAEjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;IACtB,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC;CACvB,CAAC;AAKF,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,KAAK,CAAC,QAAQ,EACtB,SAAS,yBAAyB,KACjC,yBA+DF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,KAAK,CAAC,IAAI,EAClB,YAAY,MAAM,EAClB,SAAS,iBAAiB,KACzB;IAAE,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CAoBlD,CAAC"}

package/dist/camera.js

@@ -49,6 +49,13 @@ export const normalizeObject3d = (object, config) => {
         bounds.getSize(size);
         bounds.getCenter(center);
     }
+    if (resolved.anchor) {
+        object.position.add(resolved.anchor);
+        object.updateMatrixWorld(true);
+        bounds = new THREE.Box3().setFromObject(object);
+        bounds.getSize(size);
+        bounds.getCenter(center);
+    }
     return { bounds, center, size, scale, offset };
 };
 export const computeCameraFrame = (bounds, fovDegrees, config) => {
@@ -64,7 +71,7 @@ export const computeCameraFrame = (bounds, fovDegrees, config) => {
     const padding = config?.padding ?? DEFAULT_FRAME_PADDING;
     const direction = new THREE.Vector3(...(config?.direction ?? DEFAULT_FRAME_DIRECTION)).normalize();
     const sphere = bounds.getBoundingSphere(new THREE.Sphere());
-    const radius = Math.max(0.5, sphere.radius);
+    const radius = Math.max(0.05, sphere.radius);
     const vFov = THREE.MathUtils.degToRad(fovDegrees);
     const distance = (radius / Math.sin(vFov / 2)) * padding;
     const position = center.clone().add(direction.multiplyScalar(distance));

package/dist/engine/ViewerEngine.d.ts

@@ -1,13 +1,23 @@
 import type { CameraState, RenderPresetDefinition, ViewerCreateOptions, ViewerHandle, ViewerSnapshot } from "./types";
 export declare class ViewerEngine {
     private static readonly RUNTIME_PRESET_ID;
+    private static readonly DEFAULT_NEAR_SAFETY;
+    private static readonly DEFAULT_FAR_SAFETY;
+    private static readonly DEFAULT_MINIMUM_FAR;
+    private static readonly DEFAULT_CONTROL_MAX_DISTANCE_FACTOR;
+    private static readonly DEFAULT_CONTROL_MIN_DISTANCE_FACTOR;
     private container;
     private renderer;
     private scene;
     private camera;
+    private perspectiveCamera;
+    private orthographicCamera;
+    private cameraKind;
+    private orthographicHeight;
     private controls;
     private rootGroup;
     private sceneBounds;
+    private sceneSphere;
     private environmentSystem;
     private lightingSystem;
     private postFxSystem;
@@ -21,7 +31,15 @@ export declare class ViewerEngine {
     private lastHeight;
     private maxPixelRatio;
     private hasDominantGroundPlane;
+    private resolveDebugPreset;
+    private applySceneSystems;
+    private disposeObject3d;
     constructor(options: ViewerCreateOptions);
+    private syncOrthographicFrustum;
+    private switchCamera;
+    private updateCameraClipping;
+    private refreshSceneClipping;
+    private refreshControlLimits;
     getHandle(): ViewerHandle;
     private invalidate;
     start(): void;
@@ -34,6 +52,8 @@ export declare class ViewerEngine {
     setCamera(state: Partial<CameraState>): void;
     getCameraState(): CameraState;
     capturePng(): Promise<Blob>;
+    private captureVisibleCanvas;
+    private captureOffscreenRender;
     getSnapshot(): ViewerSnapshot;
     private getDebugInfo;
     private applyPreset;

package/dist/engine/ViewerEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewerEngine.d.ts","sourceRoot":"","sources":["../../src/engine/ViewerEngine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAiB,WAAW,EAAiB,sBAAsB,EAAE,mBAAmB,EAAmB,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAQrK,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAiB;IAE1D,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,WAAW,CAA2B;IAE9C,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,iBAAiB,CAAU;IAEnC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;IAE9B,OAAO,CAAC,sBAAsB;gBAiClB,OAAO,EAAE,mBAAmB;IAwDxC,SAAS,IAAI,YAAY;IA0BzB,OAAO,CAAC,UAAU;IAKlB,KAAK,IAAI,IAAI;IAiBb,IAAI,IAAI,IAAI;IAQZ,MAAM,IAAI,IAAI;IAcd,OAAO,IAAI,IAAI;IAef,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIjC,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAStD,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IA8DjC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI;IAuB5C,cAAc,IAAI,WAAW;IAUvB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmCjC,WAAW,IAAI,cAAc;IAe7B,OAAO,CAAC,YAAY;IAuCpB,OAAO,CAAC,WAAW;IAyBnB,OAAO,CAAC,aAAa;CAKtB"}
+{"version":3,"file":"ViewerEngine.d.ts","sourceRoot":"","sources":["../../src/engine/ViewerEngine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,WAAW,EAEX,sBAAsB,EACtB,mBAAmB,EAEnB,YAAY,EACZ,cAAc,EACf,MAAM,SAAS,CAAC;AAQjB,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAiB;IAC1D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAO;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAQ;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAO;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mCAAmC,CAAM;IACjE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mCAAmC,CAAS;IAEpE,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,iBAAiB,CAA0B;IACnD,OAAO,CAAC,kBAAkB,CAA2B;IACrD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,WAAW,CAA6B;IAEhD,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,iBAAiB,CAAU;IAEnC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAS;IAE9B,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,eAAe;gBA0CX,OAAO,EAAE,mBAAmB;IA0ExC,OAAO,CAAC,uBAAuB;IAa/B,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,oBAAoB;IAiB5B,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,oBAAoB;IAgB5B,SAAS,IAAI,YAAY;IA0BzB,OAAO,CAAC,UAAU;IAKlB,KAAK,IAAI,IAAI;IAmBb,IAAI,IAAI,IAAI;IAQZ,MAAM,IAAI,IAAI;IAed,OAAO,IAAI,IAAI;IAsBf,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAIjC,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAStD,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAgCjC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI;IA2B5C,cAAc,IAAI,WAAW;IAkBvB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YASnB,oBAAoB;YAmCpB,sBAAsB;IAmCpC,WAAW,IAAI,cAAc;IAe7B,OAAO,CAAC,YAAY;IAmDpB,OAAO,CAAC,WAAW;IAwBnB,OAAO,CAAC,aAAa;CAKtB"}

package/dist/engine/ViewerEngine.js

@@ -8,13 +8,23 @@ import { PostFxSystem } from "../systems/postfxSystem";
 import { DebugSystem } from "../systems/debugSystem";
 export class ViewerEngine {
     static RUNTIME_PRESET_ID = "__runtime__";
+    static DEFAULT_NEAR_SAFETY = 1.6;
+    static DEFAULT_FAR_SAFETY = 1.15;
+    static DEFAULT_MINIMUM_FAR = 220;
+    static DEFAULT_CONTROL_MAX_DISTANCE_FACTOR = 18;
+    static DEFAULT_CONTROL_MIN_DISTANCE_FACTOR = 0.025;
     container;
     renderer;
     scene;
     camera;
+    perspectiveCamera;
+    orthographicCamera;
+    cameraKind;
+    orthographicHeight;
     controls;
     rootGroup;
     sceneBounds = null;
+    sceneSphere = null;
     environmentSystem;
     lightingSystem;
     postFxSystem;
@@ -62,6 +72,63 @@ export class ViewerEngine {
         });
         return detected;
     }
+    resolveDebugPreset(preset) {
+        if (!this.hasDominantGroundPlane(this.rootGroup, this.sceneBounds))
+            return preset;
+        return {
+            ...preset,
+            sceneExtras: {
+                ...(preset.sceneExtras ?? {}),
+                ground: false,
+            },
+        };
+    }
+    applySceneSystems(preset) {
+        this.lightingSystem.apply(preset, this.sceneBounds);
+        this.debugSystem.apply(this.resolveDebugPreset(preset), this.sceneBounds, this.rootGroup);
+    }
+    disposeObject3d(object) {
+        object.traverse((child) => {
+            const mesh = child;
+            if (mesh.isMesh) {
+                const geometry = mesh.geometry;
+                geometry?.dispose?.();
+                const material = mesh.material;
+                if (Array.isArray(material)) {
+                    material.forEach((mat) => mat.dispose?.());
+                }
+                else {
+                    material?.dispose?.();
+                }
+                return;
+            }
+            const line = child;
+            if (line.isLine) {
+                const geometry = line.geometry;
+                geometry?.dispose?.();
+                const material = line.material;
+                if (Array.isArray(material)) {
+                    material.forEach((mat) => mat.dispose?.());
+                }
+                else {
+                    material?.dispose?.();
+                }
+                return;
+            }
+            const points = child;
+            if (points.isPoints) {
+                const geometry = points.geometry;
+                geometry?.dispose?.();
+                const material = points.material;
+                if (Array.isArray(material)) {
+                    material.forEach((mat) => mat.dispose?.());
+                }
+                else {
+                    material?.dispose?.();
+                }
+            }
+        });
+    }
     constructor(options) {
         this.container = options.container;
         const basePresets = options.presets ?? DEFAULT_PRESETS;
@@ -70,13 +137,23 @@ export class ViewerEngine {
         const width = this.container.clientWidth || 1;
         const height = this.container.clientHeight || 1;
         this.scene = new THREE.Scene();
-        this.camera = new THREE.PerspectiveCamera(options.camera?.fov ?? 60, width / height, options.camera?.near ?? 0.1, options.camera?.far ?? 500);
+        this.perspectiveCamera = new THREE.PerspectiveCamera(options.camera?.fov ?? 60, width / height, options.camera?.near ?? 0.1, options.camera?.far ?? 500);
+        this.orthographicHeight = options.camera?.orthographicHeight ?? 24;
+        const aspect = width / height;
+        const halfHeight = this.orthographicHeight / 2;
+        const halfWidth = halfHeight * aspect;
+        this.orthographicCamera = new THREE.OrthographicCamera(-halfWidth, halfWidth, halfHeight, -halfHeight, options.camera?.near ?? 0.1, options.camera?.far ?? 500);
         const camPos = options.camera?.position ?? [15, 12, 15];
-        this.camera.position.set(...camPos);
+        this.perspectiveCamera.position.set(...camPos);
+        this.orthographicCamera.position.set(...camPos);
+        this.cameraKind = options.camera?.kind ?? "perspective";
+        this.camera = this.cameraKind === "orthographic" ? this.orthographicCamera : this.perspectiveCamera;
+        const initialRendererConfig = this.resolvePreset(this.presetId).renderer;
         const rendererOptions = {
-            antialias: options.renderer?.antialias ?? true,
-            alpha: options.renderer?.alpha ?? false,
-            preserveDrawingBuffer: options.renderer?.preserveDrawingBuffer ?? false,
+            antialias: options.renderer?.antialias ?? initialRendererConfig?.antialias ?? true,
+            alpha: options.renderer?.alpha ?? initialRendererConfig?.alpha ?? false,
+            preserveDrawingBuffer: options.renderer?.preserveDrawingBuffer ?? initialRendererConfig?.preserveDrawingBuffer ?? false,
+            powerPreference: options.renderer?.powerPreference ?? initialRendererConfig?.powerPreference ?? "high-performance",
         };
         this.renderer = new THREE.WebGLRenderer(rendererOptions);
         this.renderer.setSize(width, height);
@@ -85,6 +162,7 @@ export class ViewerEngine {
         this.controls.enableDamping = true;
         this.controls.dampingFactor = 0.05;
         this.controls.addEventListener("change", () => {
+            this.refreshSceneClipping();
             if (this.usePostprocessing) {
                 this.postFxSystem.invalidate();
             }
@@ -105,6 +183,79 @@ export class ViewerEngine {
         this.postFxSystem.resize(width, height);
         this.applyPreset(this.presetId);
     }
+    syncOrthographicFrustum(height) {
+        const safeHeight = Number.isFinite(height) && height > 0 ? height : this.orthographicHeight || 24;
+        this.orthographicHeight = safeHeight;
+        const aspect = this.lastWidth / Math.max(1, this.lastHeight);
+        const halfHeight = safeHeight / 2;
+        const halfWidth = halfHeight * aspect;
+        this.orthographicCamera.left = -halfWidth;
+        this.orthographicCamera.right = halfWidth;
+        this.orthographicCamera.top = halfHeight;
+        this.orthographicCamera.bottom = -halfHeight;
+        this.orthographicCamera.updateProjectionMatrix();
+    }
+    switchCamera(kind) {
+        if (this.cameraKind === kind)
+            return;
+        const currentTarget = this.controls.target.clone();
+        const currentPosition = this.camera.position.clone();
+        this.cameraKind = kind;
+        this.camera = kind === "orthographic" ? this.orthographicCamera : this.perspectiveCamera;
+        this.camera.position.copy(currentPosition);
+        this.controls.object = this.camera;
+        this.controls.target.copy(currentTarget);
+        this.controls.update();
+        this.postFxSystem.setCamera(this.camera);
+        this.environmentSystem.update(this.camera);
+    }
+    updateCameraClipping(camera, near, far) {
+        if (camera instanceof THREE.PerspectiveCamera || camera instanceof THREE.OrthographicCamera) {
+            let needsUpdate = false;
+            if (typeof near === "number" && Number.isFinite(near) && camera.near !== near) {
+                camera.near = near;
+                needsUpdate = true;
+            }
+            if (typeof far === "number" && Number.isFinite(far) && camera.far !== far) {
+                camera.far = far;
+                needsUpdate = true;
+            }
+            if (needsUpdate) {
+                camera.updateProjectionMatrix();
+            }
+        }
+    }
+    refreshSceneClipping() {
+        if (!this.sceneSphere || !Number.isFinite(this.sceneSphere.radius) || this.sceneSphere.radius <= 0)
+            return;
+        const distanceToCenter = this.camera.position.distanceTo(this.sceneSphere.center);
+        if (!Number.isFinite(distanceToCenter) || distanceToCenter <= 0)
+            return;
+        let near = Math.max(0.005, distanceToCenter - this.sceneSphere.radius * ViewerEngine.DEFAULT_NEAR_SAFETY);
+        const maxNear = distanceToCenter * 0.08;
+        if (Number.isFinite(maxNear) && maxNear > 0) {
+            near = Math.min(near, maxNear);
+        }
+        const dynamicMinimumFar = Math.max(1, distanceToCenter * 1.4, this.sceneSphere.radius * 5);
+        const minimumFar = Math.min(ViewerEngine.DEFAULT_MINIMUM_FAR, dynamicMinimumFar);
+        const far = Math.max(distanceToCenter + this.sceneSphere.radius * ViewerEngine.DEFAULT_FAR_SAFETY, near + this.sceneSphere.radius * 2, minimumFar);
+        this.updateCameraClipping(this.perspectiveCamera, near, far);
+        this.updateCameraClipping(this.orthographicCamera, near, far);
+    }
+    refreshControlLimits() {
+        if (!this.sceneSphere || !Number.isFinite(this.sceneSphere.radius) || this.sceneSphere.radius <= 0) {
+            this.controls.minDistance = 0.05;
+            this.controls.maxDistance = Infinity;
+            this.controls.minZoom = 0.01;
+            this.controls.maxZoom = Infinity;
+            return;
+        }
+        const radius = Math.max(this.sceneSphere.radius, 0.05);
+        this.controls.minDistance = Math.max(0.02, radius * ViewerEngine.DEFAULT_CONTROL_MIN_DISTANCE_FACTOR);
+        this.controls.maxDistance = Math.max(20, radius * ViewerEngine.DEFAULT_CONTROL_MAX_DISTANCE_FACTOR);
+        this.controls.minZoom = 0.05;
+        this.controls.maxZoom = 80;
+    }
     getHandle() {
         return {
             start: () => this.start(),
@@ -142,6 +293,8 @@ export class ViewerEngine {
             if (!this.running)
                 return;
             this.controls.update();
+            this.refreshSceneClipping();
+            this.debugSystem.update(this.controls.target);
             this.environmentSystem.update(this.camera);
             if (this.usePostprocessing) {
                 this.postFxSystem.render();
@@ -167,8 +320,9 @@ export class ViewerEngine {
         this.lastHeight = height;
         const deviceRatio = typeof window !== "undefined" ? window.devicePixelRatio : 1;
         this.renderer.setPixelRatio(Math.min(deviceRatio, this.maxPixelRatio));
-        this.camera.aspect = width / height;
-        this.camera.updateProjectionMatrix();
+        this.perspectiveCamera.aspect = width / height;
+        this.perspectiveCamera.updateProjectionMatrix();
+        this.syncOrthographicFrustum(this.orthographicHeight);
         this.renderer.setSize(width, height);
         this.postFxSystem.resize(width, height);
         this.postFxSystem.invalidate();
@@ -179,9 +333,17 @@ export class ViewerEngine {
         this.lightingSystem.dispose();
         this.postFxSystem.dispose();
         this.debugSystem.dispose();
+        this.rootGroup.children.forEach((child) => this.disposeObject3d(child));
+        this.rootGroup.clear();
         this.scene.clear();
         this.controls.dispose();
         this.renderer.dispose();
+        try {
+            this.renderer.forceContextLoss();
+        }
+        catch {
+            // Some browser contexts do not expose explicit context-loss cleanup.
+        }
         if (this.renderer.domElement.parentElement === this.container) {
             this.container.removeChild(this.renderer.domElement);
         }
@@ -198,99 +360,118 @@ export class ViewerEngine {
         this.applyPreset(ViewerEngine.RUNTIME_PRESET_ID);
     }
     setSceneRoot(root) {
+        this.rootGroup.children.forEach((child) => this.disposeObject3d(child));
         this.rootGroup.clear();
+        this.sceneBounds = null;
+        this.sceneSphere = null;
         const object3d = root;
         if (object3d && object3d.isObject3D) {
             this.rootGroup.add(object3d);
             const bounds = new THREE.Box3().setFromObject(object3d);
             this.sceneBounds = bounds.clone();
             if (!bounds.isEmpty()) {
-                const size = new THREE.Vector3();
-                bounds.getSize(size);
-                const maxDim = Math.max(size.x, size.y, size.z);
-                if (Number.isFinite(maxDim) && maxDim > 0) {
-                    const target = this.controls.target.clone();
-                    const distance = this.camera.position.distanceTo(target);
-                    const sphere = new THREE.Sphere();
-                    bounds.getBoundingSphere(sphere);
-                    const safetyFar = 1.15;
-                    const safetyNear = 1.6;
-                    let near = Math.max(0.01, distance - sphere.radius * safetyNear);
-                    const maxNear = distance * 0.1;
-                    if (Number.isFinite(maxNear) && maxNear > 0) {
-                        near = Math.min(near, maxNear);
-                    }
-                    const minSkyFar = 350;
-                    const far = Math.max(distance + sphere.radius * safetyFar, near + sphere.radius * 2, minSkyFar);
-                    let needsUpdate = false;
-                    if (Number.isFinite(near) && this.camera.near !== near) {
-                        this.camera.near = near;
-                        needsUpdate = true;
-                    }
-                    if (Number.isFinite(far) && this.camera.far !== far) {
-                        this.camera.far = far;
-                        needsUpdate = true;
-                    }
-                    if (needsUpdate) {
-                        this.camera.updateProjectionMatrix();
-                    }
+                const sphere = new THREE.Sphere();
+                bounds.getBoundingSphere(sphere);
+                if (Number.isFinite(sphere.radius) && sphere.radius > 0) {
+                    this.sceneSphere = sphere.clone();
+                    this.refreshSceneClipping();
                 }
             }
         }
-        // Re-apply scene extras (ground/grid) to match updated bounds.
+        this.refreshControlLimits();
+        // Re-apply scene-bound systems after a root swap so workplane, shadows, and helpers match current geometry.
         try {
             const preset = this.resolvePreset(this.presetId);
-            const disableGround = this.hasDominantGroundPlane(this.rootGroup, this.sceneBounds);
-            const debugPreset = disableGround
-                ? {
-                    ...preset,
-                    sceneExtras: {
-                        ...(preset.sceneExtras ?? {}),
-                        ground: false,
-                    },
-                }
-                : preset;
-            this.debugSystem.apply(debugPreset, this.sceneBounds);
+            this.applySceneSystems(preset);
         }
         catch {
-            // ignore debug system failures
+            // ignore presentation system failures
         }
         this.postFxSystem.invalidate();
         // Ensure the render loop is running after a scene update.
         this.start();
     }
     setCamera(state) {
+        if (state.kind) {
+            this.switchCamera(state.kind);
+        }
         if (state.position) {
             this.camera.position.set(...state.position);
+            const secondaryCamera = this.camera === this.perspectiveCamera ? this.orthographicCamera : this.perspectiveCamera;
+            secondaryCamera.position.set(...state.position);
         }
         if (state.target) {
             this.controls.target.set(...state.target);
         }
         if (typeof state.fov === "number") {
-            this.camera.fov = state.fov;
-            this.camera.updateProjectionMatrix();
-        }
-        if (typeof state.near === "number" && Number.isFinite(state.near)) {
-            this.camera.near = state.near;
-            this.camera.updateProjectionMatrix();
+            this.perspectiveCamera.fov = state.fov;
+            this.perspectiveCamera.updateProjectionMatrix();
         }
-        if (typeof state.far === "number" && Number.isFinite(state.far)) {
-            this.camera.far = state.far;
-            this.camera.updateProjectionMatrix();
+        if (typeof state.orthographicHeight === "number" && Number.isFinite(state.orthographicHeight)) {
+            this.syncOrthographicFrustum(state.orthographicHeight);
         }
+        this.updateCameraClipping(this.perspectiveCamera, state.near, state.far);
+        this.updateCameraClipping(this.orthographicCamera, state.near, state.far);
         this.controls.update();
+        this.refreshControlLimits();
+        this.refreshSceneClipping();
         this.postFxSystem.invalidate();
     }
     getCameraState() {
         return {
+            kind: this.cameraKind,
             position: [this.camera.position.x, this.camera.position.y, this.camera.position.z],
             target: [this.controls.target.x, this.controls.target.y, this.controls.target.z],
-            fov: this.camera.fov,
-            near: this.camera.near,
-            far: this.camera.far,
+            fov: this.perspectiveCamera.fov,
+            orthographicHeight: this.orthographicHeight,
+            near: this.camera instanceof THREE.PerspectiveCamera || this.camera instanceof THREE.OrthographicCamera
+                ? this.camera.near
+                : undefined,
+            far: this.camera instanceof THREE.PerspectiveCamera || this.camera instanceof THREE.OrthographicCamera
+                ? this.camera.far
+                : undefined,
         };
     }
     async capturePng() {
+        const visibleFrame = await this.captureVisibleCanvas();
+        if (visibleFrame) {
+            return visibleFrame;
+        }
+        return this.captureOffscreenRender();
+    }
+    async captureVisibleCanvas() {
+        const canvas = this.renderer.domElement;
+        if (!canvas || canvas.width < 1 || canvas.height < 1) {
+            return null;
+        }
+        this.controls.update();
+        this.debugSystem.update(this.controls.target);
+        this.environmentSystem.update(this.camera);
+        if (this.usePostprocessing) {
+            this.postFxSystem.render();
+        }
+        else {
+            this.renderer.setRenderTarget(null);
+            this.renderer.clear(true, true, true);
+            this.renderer.render(this.scene, this.camera);
+        }
+        const gl = this.renderer.getContext();
+        gl.finish?.();
+        try {
+            const dataUrl = canvas.toDataURL("image/png");
+            if (!dataUrl.startsWith("data:image/png")) {
+                return null;
+            }
+            const response = await fetch(dataUrl);
+            const blob = await response.blob();
+            return blob.size > 0 ? blob : null;
+        }
+        catch (error) {
+            console.warn("[viewer-kit] Visible canvas capture failed, falling back to offscreen render.", error);
+            return null;
+        }
+    }
+    async captureOffscreenRender() {
         const width = this.renderer.domElement.width || 1;
         const height = this.renderer.domElement.height || 1;
         const target = new THREE.WebGLRenderTarget(width, height);
@@ -340,6 +521,7 @@ export class ViewerEngine {
         const postfxState = this.postFxSystem.getState();
         const renderInfo = this.renderer.info.render;
         const clearColor = new THREE.Color();
+        const boundsCenter = this.sceneBounds && !this.sceneBounds.isEmpty() ? this.sceneBounds.getCenter(new THREE.Vector3()) : null;
         this.renderer.getClearColor(clearColor);
         return {
             presetId: this.presetId,
@@ -368,7 +550,17 @@ export class ViewerEngine {
                 children: this.scene.children.length,
                 rootChildren: this.rootGroup.children.length,
                 lights: this.scene.children.filter((child) => child?.isLight).length,
+                bounds: this.sceneBounds && !this.sceneBounds.isEmpty() && boundsCenter && this.sceneSphere
+                    ? {
+                        min: [this.sceneBounds.min.x, this.sceneBounds.min.y, this.sceneBounds.min.z],
+                        max: [this.sceneBounds.max.x, this.sceneBounds.max.y, this.sceneBounds.max.z],
+                        center: [boundsCenter.x, boundsCenter.y, boundsCenter.z],
+                        radius: this.sceneSphere.radius,
+                    }
+                    : null,
             },
+            workplane: this.debugSystem.getState(),
+            lighting: this.lightingSystem.getState(),
             environment: envState,
             postfx: postfxState,
         };
@@ -390,10 +582,9 @@ export class ViewerEngine {
         this.renderer.setSize(this.lastWidth, this.lastHeight);
         this.postFxSystem.resize(this.lastWidth, this.lastHeight);
         void this.environmentSystem.apply(preset);
-        this.lightingSystem.apply(preset);
+        this.applySceneSystems(preset);
         this.postFxSystem.apply(this.usePostprocessing ? preset.postfx : undefined);
         this.postFxSystem.invalidate();
-        this.debugSystem.apply(preset, this.sceneBounds);
     }
     resolvePreset(presetId) {
         if (presetId in this.presets)