@smarterplan/ngx-smarterplan-core 1.4.20 → 1.4.22

package/fesm2022/smarterplan-ngx-smarterplan-core.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Injectable, Input, Component, InjectionToken, Inject, EventEmitter, isDevMode, Output, Pipe, ViewChild, NgModule } from '@angular/core';
+import { Injectable, Input, Component, InjectionToken, Inject, EventEmitter, isDevMode, Output, Pipe, ViewChild, HostListener, NgModule } from '@angular/core';
 import * as i1 from '@ngx-translate/core';
 import { TranslateModule } from '@ngx-translate/core';
 import { Subject, BehaviorSubject, takeUntil, Observable } from 'rxjs';
@@ -8,7 +8,7 @@ import { NgbDate, NgbModule } from '@ng-bootstrap/ng-bootstrap';
 import * as i1$1 from '@angular/router';
 import { RouterModule } from '@angular/router';
 import * as THREE from 'three';
-import { Matrix4, Vector3, Color, Object3D, Euler, PerspectiveCamera, CylinderBufferGeometry, BoxGeometry, MeshBasicMaterial, NormalBlending, BackSide, Mesh, EdgesGeometry, AdditiveBlending, ShaderMaterial, AnimationMixer, VectorKeyframeTrack, InterpolateSmooth, AnimationClip, LoopOnce, Group, PlaneBufferGeometry, CanvasTexture, Texture, LinearFilter } from 'three';
+import { Matrix4, Vector3, Color, Object3D, Euler, PerspectiveCamera, CylinderBufferGeometry, BoxGeometry, MeshBasicMaterial, NormalBlending, BackSide, Mesh, EdgesGeometry, AdditiveBlending, ShaderMaterial, AnimationMixer, VectorKeyframeTrack, InterpolateSmooth, AnimationClip, LoopOnce, Group, PlaneBufferGeometry, CanvasTexture, Texture, LinearFilter, Box3, MathUtils } from 'three';
 import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { Storage, Auth, API, graphqlOperation, Cache } from 'aws-amplify';
 import { DateTime } from 'luxon';
@@ -386,6 +386,8 @@ var ViewerInteractions;
     ViewerInteractions[ViewerInteractions["DEFAULT"] = 0] = "DEFAULT";
     ViewerInteractions[ViewerInteractions["ADDING"] = 1] = "ADDING";
     ViewerInteractions[ViewerInteractions["POSITIONING"] = 2] = "POSITIONING";
+    /** A loaded 3D object follows the cursor until the user clicks (validate) or cancels */
+    ViewerInteractions[ViewerInteractions["PLACING_OBJECT3D"] = 3] = "PLACING_OBJECT3D";
 })(ViewerInteractions || (ViewerInteractions = {}));
 class ProfileEntity {
     id;
@@ -633,7 +635,9 @@ class SecurityCamera extends SceneComponent {
         this.makeHighlight();
         // attach highighting to the mesh it represents
         // TODO (scene query): this is very brittle but is the only way to attach something to a room of the model
-        this.outputs.objectRoot.parent.parent.add(this.highlight);
+        if (this.highlight) {
+            this.outputs.objectRoot.parent.parent.add(this.highlight);
+        }
         // create the animation mixer to rotate the camera
         this.makeAnimation();
     }
@@ -672,6 +676,12 @@ class SecurityCamera extends SceneComponent {
             this.edges = null;
         }
         function edgesToCylinders(edgesGeometry, thickness) {
+            // API to be updated in bundle - JSSDK-1222
+            const merge = THREE.mergeBufferGeometries ?? THREE.BufferGeometryUtils?.mergeBufferGeometries;
+            // not exported by the three.js of recent SDK bundles: the caller falls back to plain lines
+            if (!merge)
+                return null;
+            const Cylinder = THREE.CylinderGeometry ?? THREE.CylinderBufferGeometry;
             const { position } = edgesGeometry.attributes;
             const { array, count } = position;
             const r = thickness / 2;
@@ -681,15 +691,14 @@ class SecurityCamera extends SceneComponent {
                 const b = new THREE.Vector3(array[i + 3], array[i + 4], array[i + 5]);
                 const vec = new THREE.Vector3().subVectors(b, a);
                 const len = vec.length();
-                const geom = new THREE.CylinderBufferGeometry(r, r, len, 8);
+                const geom = new Cylinder(r, r, len, 8);
                 geom.translate(0, len / 2, 0);
                 geom.rotateX(Math.PI / 2);
                 geom.lookAt(vec);
                 geom.translate(a.x, a.y, a.z);
                 geoms.push(geom);
             }
-            // API to be updated in bundle - JSSDK-1222
-            return THREE.mergeBufferGeometries(geoms);
+            return merge(geoms);
         }
         const frustumLength = this.inputs.farPlane - this.inputs.nearPlane;
         const boxGeometry = new THREE.BoxGeometry(2, 2, frustumLength);
@@ -725,6 +734,16 @@ class SecurityCamera extends SceneComponent {
         });
         this.box = new THREE.Mesh(boxGeometry, boxMaterial);
         const edgesGeometry = edgesToCylinders(new THREE.EdgesGeometry(boxGeometry), 0.015);
+        if (!edgesGeometry) {
+            // thick edges need mergeBufferGeometries: draw the frustum with lines
+            this.edges = new THREE.LineSegments(new THREE.EdgesGeometry(boxGeometry), new THREE.LineBasicMaterial({
+                color: this.inputs.color,
+                opacity: 0.8,
+                transparent: true,
+                depthWrite: false,
+            }));
+            return;
+        }
         this.edges = new THREE.Mesh(edgesGeometry, new THREE.MeshBasicMaterial({
             color: 0xffffff,
             opacity: 0.25,
@@ -745,8 +764,12 @@ class SecurityCamera extends SceneComponent {
     makeHighlight() {
         const THREE = this.context.three;
         // TODO (scene query): this is very brittle and hardcoded but is the only way to get room geometries until we have a better way to query the scene graph
-        const floorMesh = this.outputs.objectRoot.parent.parent.getObjectByName('FloorMesh:0');
-        const roomMesh = floorMesh.children[0];
+        const floorMesh = this.outputs.objectRoot.parent?.parent?.getObjectByName('FloorMesh:0');
+        const roomMesh = floorMesh?.children[0];
+        if (!roomMesh?.geometry) {
+            // no room mesh found in the scene graph: the frustum is shown without the highlight
+            return;
+        }
         updateHighlightUniforms$1(this.projector, this.highlightUniforms);
         this.highlightUniforms.color.value.setHex(this.inputs.color);
         const shader = new THREE.ShaderMaterial({
@@ -1072,22 +1095,62 @@ const uploadFileToS3 = async (path, file, objectId) => {
         return result.key;
     });
 };
+/**
+ * Fetches fresh credentials, and says in the console how long the ones held had left: when an
+ * upload is refused, this is what tells why.
+ */
+const renewCredentials = async () => {
+    try {
+        const held = await Auth.currentCredentials();
+        const left = held?.expiration ? new Date(held.expiration).getTime() - Date.now() : 0;
+        console.info(`[upload] credentials held expire in ${Math.round(left / 60000)} min, fetching new ones`);
+        // What Amplify itself does on signing in. Nobody signs in here through a federated provider,
+        // whose stored sign-in this would also drop.
+        await Auth.Credentials.clear();
+        await Auth.currentCredentials();
+    }
+    catch (error) {
+        // The upload will say what is wrong, if anything is.
+        console.warn("[upload] could not renew the credentials:", error);
+    }
+};
+const isExpiredTokenError = (error) => /ExpiredToken|token has expired/i.test(`${error?.name ?? ""} ${error?.Code ?? ""} ${error?.message ?? error ?? ""}`);
 /**
  * Uploads a file, reporting progress as a 0-1 fraction.
  *
  * uploadFileToS3 above swallows progress, which is fine for a photo and unusable for a 3D model:
  * these run to hundreds of megabytes, and an upload with no feedback is indistinguishable from a
  * frozen page. Returns the stored key, which is what gets saved on the record.
+ *
+ * A large file is sent in parts, each signed when it is sent. Left to itself, Storage.put signs
+ * them all with whatever credentials Amplify last handed the S3 provider, for any call - credentials
+ * that last an hour at most, and an upload of a few gigabytes takes longer: every part after they
+ * expire is refused with "The provided token has expired", and fetching new ones does not help, the
+ * upload never asks for them. Passing no credentials at all makes it ask Amplify for them part by
+ * part, and Amplify renews them as they age. Should they run out anyway, it starts once more.
  */
 const uploadFileToS3WithProgress = async (path, file, onProgress) => {
-    return Storage.put(path + file.name, file, {
+    const put = () => Storage.put(path + file.name, file, {
         contentType: file.type || "application/octet-stream",
+        // Present and empty, so that it replaces the provider's own; see above.
+        credentials: undefined,
         progressCallback(progress) {
             if (onProgress && progress.total > 0) {
                 onProgress(progress.loaded / progress.total);
             }
         },
     }).then((result) => result.key);
+    try {
+        return await put();
+    }
+    catch (error) {
+        if (!isExpiredTokenError(error)) {
+            throw error;
+        }
+        console.warn("[upload] refused, the token had expired; starting again with new credentials", error);
+        await renewCredentials();
+        return put();
+    }
 };
 const getSignedImageUrlForEquipment = async (equip) => {
     if (!equip.photo) {
@@ -2293,6 +2356,69 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: ['currentAwsKinesisAnalyticsService']
                 }] }, { type: BaseUserService }, { type: ZoneChangeService }] });
 
+// matterport-framing.util.ts
+/**
+ * Camera rotation that shows `target` from `camera`, at a given horizontal place of the viewer.
+ * Matterport yaw is 0 when looking toward -Z and grows when turning left; pitch is positive upward.
+ * @param horizontalTanHalfFov tan(horizontal FOV / 2), i.e. 1 / projection[0] of the camera pose
+ * @param screenX where the target must appear, from -1 (left edge) to 1 (right edge); 0 = center.
+ *                Used when part of the viewer is covered (side panel), to frame the visible area.
+ */
+function computeFramingRotation(camera, target, horizontalTanHalfFov = 1, screenX = 0) {
+    const dx = target.x - camera.x;
+    const dy = target.y - camera.y;
+    const dz = target.z - camera.z;
+    const yawToTarget = Math.atan2(-dx, -dz);
+    // the target is seen at screenX when the camera looks that much to its side
+    const offset = Math.atan(screenX * horizontalTanHalfFov);
+    return {
+        x: toDegrees(Math.atan2(dy, Math.hypot(dx, dz))),
+        y: toDegrees(yawToTarget + offset),
+    };
+}
+/**
+ * Horizontal place (-1..1) of the center of the visible part of the viewer.
+ * @param viewer client rect of the viewer iframe
+ * @param visibleLeft / visibleRight client X bounds of the part not covered by other panels
+ */
+function visibleCenterScreenX(viewer, visibleLeft, visibleRight) {
+    if (!viewer.width)
+        return 0;
+    const left = Math.max(viewer.left, visibleLeft);
+    const right = Math.min(viewer.left + viewer.width, visibleRight);
+    if (right <= left)
+        return 0;
+    const center = (left + right) / 2;
+    return ((center - viewer.left) / viewer.width) * 2 - 1;
+}
+function toDegrees(rad) {
+    return (rad * 180) / Math.PI;
+}
+/** Height of the floor under a sweep: its puck, or 1.5 m under the camera when the SDK gives none */
+function sweepFloorY(sweep) {
+    return sweep.puckPosition?.y ?? sweep.floorPosition?.y ?? sweep.position.y - 1.5;
+}
+/**
+ * Sweep closest to an object placed at `position`, among the sweeps of the same storey: the camera
+ * of the storey below is often nearer in 3D than a sweep of the same room. A sweep is on the same
+ * storey when the object stands between 0.5 m under its floor and 3 m above it; without any such
+ * sweep, all of them are considered. Distances are measured horizontally.
+ */
+function pickNearestSweepOnSameStorey(sweeps, position) {
+    const sameStorey = sweeps.filter((s) => position.y >= s.floorY - 0.5 && position.y < s.floorY + 3);
+    const candidates = sameStorey.length > 0 ? sameStorey : sweeps;
+    let best = null;
+    let bestDist = Infinity;
+    for (const sweep of candidates) {
+        const dist = Math.hypot(sweep.position.x - position.x, sweep.position.z - position.z);
+        if (dist < bestDist) {
+            bestDist = dist;
+            best = sweep.sid;
+        }
+    }
+    return best;
+}
+
 /* eslint-disable unicorn/filename-case */
 class MattertagData {
     object;
@@ -3463,6 +3589,28 @@ class MatterportObject3DService {
     azimuthalCrown;
     threeJSScene;
     noLightForObjects = true;
+    /** Max time (ms) to wait for a model to be loaded by the SDK */
+    loadTimeoutMs = 15000;
+    /** Max distance (m) an object can travel from where a translate drag started */
+    maxDragDistance = 2;
+    /** Max vertical travel (m, up and down) during a translate drag, so an object cannot jump to another floor */
+    maxDragHeight = 1.5;
+    /** Emits on every gizmo change and on setObject3DTransform */
+    object3DTransformChanged$ = new Subject();
+    /** Security camera animators by object uuid (`securityCameraAnimator` stays the last loaded one) */
+    securityCameraAnimators = new Map();
+    viewFrustumVisible = new Map();
+    lastSecurityCameraUuid = null;
+    /** Loader component of each model (outputs.objectRoot is set once loaded) */
+    loaderComponents = new Map();
+    gizmos = new Map();
+    activeGizmoUuid = null;
+    gizmoSnap = null;
+    /** Sweeps disabled by setNavigationLocked(true), re-enabled on unlock */
+    sweepsDisabledByLock = [];
+    /** Sweeps re-enabled by the last unlock (the SDK may still report them disabled for a moment) */
+    sweepsEnabledByUnlock = [];
+    tmpBox = new Box3();
     constructor() { }
     async init3DObjectViewer(sdk) {
         const [sceneObject] = await sdk.Scene.createObjects(1);
@@ -3473,112 +3621,184 @@ class MatterportObject3DService {
         this.objectControl = nodeControl.addComponent('mp.transformControls');
         nodeControl.start();
     }
-    async add3DObject(sdk, obj, mode) {
-        return new Promise(async (resolve) => {
-            const [sceneObject] = await sdk.Scene.createObjects(1);
-            let isAnimatedSecurityCamera = (obj.object === "security_camera");
-            let isNestThermostat = (obj.object === "nest_thermostat");
-            let isSmarterplanPromotionalVideo = (obj.object === 'video');
-            let isAzimuthalCrown = (obj.object === 'azimuth');
-            const modelNode = sceneObject.addNode();
-            let component = null;
-            const initial = {
-                url: `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,
-                localRotation: { "x": 0, "y": 0, "z": 0 },
-                localPosition: { "x": 0, "y": 0, "z": 0 },
-                visible: true,
-                colliderEnabled: true
-            };
-            switch (obj.format) {
-                case '.obj':
-                case 'obj':
-                    component = modelNode.addComponent('mp.objLoader', initial);
-                    break;
-                case '.fbx':
-                case 'fbx':
-                    component = modelNode.addComponent('mp.fbxLoader', initial);
-                    break;
-                case '.gltf':
-                case 'gltf':
-                case '.glb':
-                case 'glb':
-                    component = modelNode.addComponent('mp.gltfLoader', initial);
-                    break;
-                case '.dae':
-                case 'dae':
-                    component = modelNode.addComponent('mp.daeLoader', initial);
-                    break;
-                default:
-                    console.log('Format not supported');
-                    break;
+    /** SDK loader component name for a model format, null when the format is not supported */
+    getLoaderComponentName(format) {
+        switch ((format || '').toLowerCase()) {
+            case '.obj':
+            case 'obj': return 'mp.objLoader';
+            case '.fbx':
+            case 'fbx': return 'mp.fbxLoader';
+            case '.gltf':
+            case 'gltf':
+            case '.glb':
+            case 'glb': return 'mp.gltfLoader';
+            case '.dae':
+            case 'dae': return 'mp.daeLoader';
+            default: return null;
+        }
+    }
+    /** Resolves once the loader component has produced its objectRoot, rejects after `timeoutMs` */
+    waitForModelLoaded(component, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const isLoaded = () => !!component?.outputs?.objectRoot;
+            if (isLoaded()) {
+                resolve();
+                return;
             }
-            if (this.noLightForObjects) {
-                const lightsNode = sceneObject.addNode();
-                lightsNode.addComponent('mp.ambientLight', {
-                    intensity: 1,
-                    color: { r: 1.0, g: 1.0, b: 1.0 },
-                });
-                this.noLightForObjects = false;
-            }
-            modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);
-            modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);
-            modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);
-            if (isAzimuthalCrown) {
-                this.azimuthalCrown = modelNode;
-            }
-            if (mode && !isNestThermostat) {
-                this.attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, true, true).catch((e) => console.log(e));
-            }
-            if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {
-                modelNode.obj3D.uuid = this.lastObject3D.id;
-            }
-            else if (obj.id) {
-                modelNode.obj3D.uuid = obj.id;
-            }
-            this.lastObject3D = modelNode.obj3D;
-            this.dictionnaryObjects3D.set(modelNode.obj3D.uuid, modelNode);
-            this.dictionnarySceneObjects3D.set(modelNode.obj3D.uuid, sceneObject);
-            if (isAnimatedSecurityCamera) {
-                const animator = modelNode.addComponent('mp.securityCamera', {
-                    "nearPlane": 0.1, "farPlane": 10, "horizontalFOV": 52, "aspect": 1.7777777777777777,
-                    "localPosition": { "x": 0.3, "y": 0.18, "z": 0 },
-                    "localRotation": { "x": -15, "y": -90, "z": 0 },
-                    "color": 65280, "panPeriod": 5, "panAngle": -45
-                });
-                this.securityCameraAnimator = animator;
-                if (!obj.viewFrustum) {
-                    setTimeout(() => { animator.toggleViewFrustum(); }, 1000);
+            const poll = setInterval(() => {
+                if (isLoaded()) {
+                    clearInterval(poll);
+                    clearTimeout(timer);
+                    resolve();
                 }
-            }
-            if (isNestThermostat) {
-                const cv = new CanvasRenderer();
-                cv.onInit();
-                const plane = new PlaneRenderer();
-                plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };
-                const inputTexture = cv.outputs.texture;
-                plane.setRootScene(this.threeJSScene);
-                plane.onInit(modelNode, inputTexture);
-                const sc = new NestThermostat();
-                sc.setComponent(component, plane, cv);
-                sc.setRootScene(this.threeJSScene);
-                sc.onInit(modelNode, plane, inputTexture);
-                cv.setCanvasNestThermostatPainter(sc);
-                setTimeout(() => { sc.inputs.loadingState = "Loaded"; sc.onInputsUpdated(); }, 5000);
-            }
-            if (isSmarterplanPromotionalVideo) {
-                const sc = new TvPlayer();
-                sc.setComponent(component);
-                sc.onInit(modelNode);
-                setTimeout(() => { sc.inputs.loadingState = "Loaded"; sc.onInputsUpdated(); }, 5000);
-            }
-            sceneObject.start();
-            resolve(this.lastObject3D);
+            }, 50);
+            const timer = setTimeout(() => {
+                clearInterval(poll);
+                reject(new Error(`3D model not loaded after ${timeoutMs} ms`));
+            }, timeoutMs);
         });
     }
+    /**
+     * Adds a 3D model to the scene.
+     * The promise resolves with the three.js object once the model is actually loaded, and rejects
+     * (after cleaning the scene) when the format is unknown or the load times out.
+     * The position / rotation / scale of `obj` are applied to the model origin, as stored in DB.
+     */
+    async add3DObject(sdk, obj, mode) {
+        const loaderName = this.getLoaderComponentName(obj.format);
+        if (!loaderName) {
+            throw new Error(`3D object format not supported: ${obj.format}`);
+        }
+        const [sceneObject] = await sdk.Scene.createObjects(1);
+        const isAnimatedSecurityCamera = (!obj.url && obj.object === 'security_camera');
+        const isNestThermostat = (!obj.url && obj.object === 'nest_thermostat');
+        const isSmarterplanPromotionalVideo = (!obj.url && obj.object === 'video');
+        const isAzimuthalCrown = (!obj.url && obj.object === 'azimuth');
+        const modelNode = sceneObject.addNode();
+        const initial = {
+            url: obj.url || `/assets/3Dobjects/objects/${obj.object}${obj.format.indexOf('.') === -1 ? '.' + obj.format : obj.format}`,
+            localRotation: { 'x': 0, 'y': 0, 'z': 0 },
+            localPosition: { 'x': 0, 'y': 0, 'z': 0 },
+            visible: true,
+            colliderEnabled: true
+        };
+        const component = modelNode.addComponent(loaderName, initial);
+        if (this.noLightForObjects) {
+            const lightsNode = sceneObject.addNode();
+            lightsNode.addComponent('mp.ambientLight', {
+                intensity: 1,
+                color: { r: 1.0, g: 1.0, b: 1.0 },
+            });
+            this.noLightForObjects = false;
+        }
+        modelNode.obj3D.position.set(obj.position.x, obj.position.y, obj.position.z);
+        modelNode.obj3D.rotation.set(obj.rotation.x, obj.rotation.y, obj.rotation.z);
+        modelNode.obj3D.scale.set(obj.scale.x, obj.scale.y, obj.scale.z);
+        // The DB id replaces the three.js uuid. The id pre-set through setLastObject3D is only a fallback
+        // for callers without id: taking it first gave the same id to every object loaded meanwhile
+        // (several cameras or cubes loading while an add is starting), which then overwrote each other.
+        if (obj.id) {
+            modelNode.obj3D.uuid = obj.id;
+        }
+        else if (this.lastObject3D && typeof this.lastObject3D.id === 'string') {
+            modelNode.obj3D.uuid = this.lastObject3D.id;
+        }
+        const uuid = modelNode.obj3D.uuid;
+        this.lastObject3D = modelNode.obj3D;
+        this.dictionnaryObjects3D.set(uuid, modelNode);
+        this.dictionnarySceneObjects3D.set(uuid, sceneObject);
+        this.loaderComponents.set(uuid, component);
+        if (isAzimuthalCrown) {
+            this.azimuthalCrown = modelNode;
+        }
+        if (mode && !isNestThermostat) {
+            this.attachGizmo(uuid, mode).catch(() => { });
+        }
+        let animator = null;
+        if (isAnimatedSecurityCamera) {
+            animator = modelNode.addComponent('mp.securityCamera', {
+                'nearPlane': 0.1, 'farPlane': 10, 'horizontalFOV': 52, 'aspect': 1.7777777777777777,
+                'localPosition': { 'x': 0.3, 'y': 0.18, 'z': 0 },
+                'localRotation': { 'x': -15, 'y': -90, 'z': 0 },
+                'color': 65280, 'panPeriod': 5, 'panAngle': -45
+            });
+            this.securityCameraAnimator = animator;
+            this.securityCameraAnimators.set(uuid, animator);
+            this.viewFrustumVisible.set(uuid, true); // the component shows its frustum by default
+            this.lastSecurityCameraUuid = uuid;
+        }
+        if (isNestThermostat) {
+            const cv = new CanvasRenderer();
+            cv.onInit();
+            const plane = new PlaneRenderer();
+            plane.outputs = { objectRoot: new Object3D(), collider: new Object3D() };
+            const inputTexture = cv.outputs.texture;
+            plane.setRootScene(this.threeJSScene);
+            plane.onInit(modelNode, inputTexture);
+            const sc = new NestThermostat();
+            sc.setComponent(component, plane, cv);
+            sc.setRootScene(this.threeJSScene);
+            sc.onInit(modelNode, plane, inputTexture);
+            cv.setCanvasNestThermostatPainter(sc);
+            setTimeout(() => { sc.inputs.loadingState = 'Loaded'; sc.onInputsUpdated(); }, 5000);
+        }
+        if (isSmarterplanPromotionalVideo) {
+            const sc = new TvPlayer();
+            sc.setComponent(component);
+            sc.onInit(modelNode);
+            setTimeout(() => { sc.inputs.loadingState = 'Loaded'; sc.onInputsUpdated(); }, 5000);
+        }
+        sceneObject.start();
+        try {
+            await this.waitForModelLoaded(component, this.loadTimeoutMs);
+        }
+        catch (e) {
+            await this.deleteObject3D(uuid);
+            throw e;
+        }
+        if (animator && !obj.viewFrustum) {
+            // The camera component starts with the model node, so it is ready now that the model is loaded
+            this.applyViewFrustum(uuid, false);
+        }
+        return modelNode.obj3D;
+    }
+    /**
+     * Removes a 3D object for good: detaches its gizmo, stops its scene object and forgets it.
+     */
     async deleteObject3D(uuid) {
-        const obj = this.dictionnaryObjects3D.get(uuid);
-        if (obj)
-            obj.obj3D.visible = false;
+        this.detachGizmo(uuid);
+        const node = this.dictionnaryObjects3D.get(uuid);
+        const sceneObject = this.dictionnarySceneObjects3D.get(uuid);
+        if (node) {
+            try {
+                node.obj3D.visible = false;
+            }
+            catch { /* already destroyed */ }
+        }
+        if (sceneObject && typeof sceneObject.stop === 'function') {
+            try {
+                sceneObject.stop();
+            }
+            catch { /* already stopped */ }
+        }
+        this.dictionnaryObjects3D.delete(uuid);
+        this.dictionnarySceneObjects3D.delete(uuid);
+        this.loaderComponents.delete(uuid);
+        if (this.lastObject3D && (this.lastObject3D.uuid === uuid || this.lastObject3D.id === uuid)) {
+            this.lastObject3D = null;
+        }
+        if (node && this.azimuthalCrown === node) {
+            this.azimuthalCrown = null;
+        }
+        const animator = this.securityCameraAnimators.get(uuid);
+        if (animator && this.securityCameraAnimator === animator) {
+            this.securityCameraAnimator = null;
+        }
+        this.securityCameraAnimators.delete(uuid);
+        this.viewFrustumVisible.delete(uuid);
+        if (this.lastSecurityCameraUuid === uuid) {
+            this.lastSecurityCameraUuid = null;
+        }
     }
     getObject3DModelNodeFromDictionnary(uuid) {
         let obj = this.dictionnaryObjects3D.get(uuid);
@@ -3598,10 +3818,32 @@ class MatterportObject3DService {
         let obj = this.dictionnaryObjects3D.get(objectId);
         return obj ? obj.obj3D.visible : false;
     }
+    /** Shows / hides a model (used by the placement preview) */
+    setObject3DVisible(uuid, visible) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (node)
+            node.obj3D.visible = visible;
+    }
+    /** Enables / disables the pointer collider of a model (disabled while it follows the cursor) */
+    setObject3DColliderEnabled(uuid, enabled) {
+        const component = this.loaderComponents.get(uuid);
+        if (component?.inputs) {
+            component.inputs.colliderEnabled = enabled;
+        }
+    }
+    /**
+     * Moves the camera next to a 3D object by creating a temporary tag on the object centre.
+     * @returns false when the object is unknown or no tag could be reached
+     */
     async pointCameraTo3DObject(sdk, objectId, createTagCallback, goToTagCallback, deleteLastTagCallback, getTagFromElementId) {
-        let obj = this.dictionnaryObjects3D.get(objectId);
+        const obj = this.dictionnaryObjects3D.get(objectId);
+        if (!obj)
+            return false;
+        // Tag on the bounding box centre (the model origin is a corner for most models)
+        const box = this.getObject3DBoundingBox(objectId);
+        const anchor = box ? box.center : this.toPoint(obj.obj3D.position);
         const poiObject = {
-            coordinate: JSON.stringify(obj.obj3D.position),
+            coordinate: JSON.stringify(anchor),
             type: PoiType.OBJECT3D,
             elementID: objectId,
         };
@@ -3610,9 +3852,16 @@ class MatterportObject3DService {
             await createTagCallback(PoiType.OBJECT3D, objectDb, poiObject);
         }
         catch (err) { }
-        let result = getTagFromElementId(objectId);
-        await goToTagCallback(result.tag);
-        deleteLastTagCallback();
+        try {
+            const result = getTagFromElementId(objectId);
+            if (!result?.tag)
+                return false;
+            await goToTagCallback(result.tag);
+            return true;
+        }
+        finally {
+            deleteLastTagCallback();
+        }
     }
     getSceneNodeFromObject3DId(uuid) {
         return this.dictionnarySceneObjects3D.get(uuid);
@@ -3622,49 +3871,449 @@ class MatterportObject3DService {
             this.azimuthalCrown.obj3D.position.set(poseCamera.position.x, poseCamera.position.y, poseCamera.position.z);
         }
     }
+    //
+    // ---------- Geometry helpers ----------
+    //
+    toPoint(v) {
+        return { x: v.x, y: v.y, z: v.z };
+    }
+    /**
+     * Geometry of the model itself (the loader output): the node also holds the helpers added by other
+     * components, like the view frustum of a security camera, which must not count in its size.
+     */
+    modelRoot(uuid, node) {
+        return this.loaderComponents.get(uuid)?.outputs?.objectRoot ?? node.obj3D;
+    }
+    /** World-space bounding box of the model, null when unknown or when nothing is loaded yet */
+    getObject3DBoundingBox(uuid) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return null;
+        node.obj3D.updateWorldMatrix(true, true);
+        const box = this.tmpBox.setFromObject(this.modelRoot(uuid, node));
+        if (box.isEmpty())
+            return null;
+        const size = box.getSize(new Vector3());
+        const center = box.getCenter(new Vector3());
+        return {
+            min: this.toPoint(box.min),
+            max: this.toPoint(box.max),
+            size: this.toPoint(size),
+            center: this.toPoint(center),
+        };
+    }
+    /**
+     * Real dimensions of the model in meters (width x, height y, depth z), scale included but not
+     * its rotation: the world bounding box of a rotated object is larger than the object itself.
+     */
+    getObject3DDimensions(uuid) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return null;
+        const rotation = node.obj3D.rotation.clone();
+        node.obj3D.rotation.set(0, 0, 0);
+        try {
+            node.obj3D.updateWorldMatrix(true, true);
+            const box = this.tmpBox.setFromObject(this.modelRoot(uuid, node));
+            return box.isEmpty() ? null : this.toPoint(box.getSize(new Vector3()));
+        }
+        finally {
+            node.obj3D.rotation.copy(rotation);
+            node.obj3D.updateWorldMatrix(true, true);
+        }
+    }
+    /**
+     * Uniform scale so that the largest bounding box dimension equals `targetSizeMeters`.
+     * The node position is untouched, so call placeObject3DOnSurface afterwards.
+     * @returns the new scale, null when the object is unknown / not loaded / `targetSizeMeters` invalid
+     */
+    normalizeObject3DSize(uuid, targetSizeMeters) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        const box = this.getObject3DBoundingBox(uuid);
+        if (!node || !box || !(targetSizeMeters > 0))
+            return null;
+        const largest = Math.max(box.size.x, box.size.y, box.size.z);
+        if (!(largest > 0))
+            return null;
+        const factor = targetSizeMeters / largest;
+        node.obj3D.scale.multiplyScalar(factor);
+        this.emitTransformChanged(uuid);
+        return this.toPoint(node.obj3D.scale);
+    }
+    /**
+     * Places the model on a surface point without touching its pivot: the node position is
+     * adjusted so that the bounding box bottom-center lies on `point`.
+     * - floor (normal pointing up, or no normal): bottom-center on the point
+     * - wall (mostly horizontal normal): model turned around Y so its +Z faces away from the wall,
+     *   and pushed along the normal by half its depth so it does not cut the wall
+     * - ceiling (normal pointing down): the model hangs, top-center on the point
+     * @returns the new transform, null when the object is unknown or not loaded
+     */
+    /**
+     * @param frontYawOffset rotation (radians, around Y) that turns the front of the model toward its +Z
+     *                       axis, for models whose front is another axis (e.g. -PI/2 when it is +X)
+     */
+    placeObject3DOnSurface(uuid, point, normal, frontYawOffset = 0) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node || !this.getObject3DBoundingBox(uuid))
+            return null;
+        const obj = node.obj3D;
+        const n = normal ? new Vector3(normal.x, normal.y, normal.z) : new Vector3(0, 1, 0);
+        if (n.lengthSq() === 0)
+            n.set(0, 1, 0);
+        n.normalize();
+        const isWall = Math.abs(n.y) < 0.5;
+        const isCeiling = !isWall && n.y < 0;
+        const target = new Vector3(point.x, point.y, point.z);
+        if (isWall) {
+            // Face away from the wall; the box has to be measured after the rotation
+            obj.rotation.y = Math.atan2(n.x, n.z) + frontYawOffset;
+        }
+        const box = this.getObject3DBoundingBox(uuid);
+        if (isWall) {
+            const horizontal = new Vector3(n.x, 0, n.z).normalize();
+            const halfDepth = 0.5 * (Math.abs(horizontal.x) * box.size.x + Math.abs(horizontal.z) * box.size.z);
+            target.addScaledVector(horizontal, halfDepth);
+        }
+        const anchorY = isCeiling ? box.max.y : box.min.y;
+        obj.position.x += target.x - box.center.x;
+        obj.position.y += target.y - anchorY;
+        obj.position.z += target.z - box.center.z;
+        this.emitTransformChanged(uuid);
+        return this.getObject3DTransform(uuid);
+    }
+    getObject3DTransform(uuid) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return null;
+        const o = node.obj3D;
+        return {
+            position: this.toPoint(o.position),
+            rotation: { x: o.rotation.x, y: o.rotation.y, z: o.rotation.z },
+            scale: this.toPoint(o.scale),
+        };
+    }
+    /** Applies a (partial) transform. Rotation is in radians. */
+    setObject3DTransform(uuid, transform) {
+        const node = this.dictionnaryObjects3D.get(uuid);
+        if (!node)
+            return false;
+        const o = node.obj3D;
+        if (transform.position)
+            o.position.set(transform.position.x, transform.position.y, transform.position.z);
+        if (transform.rotation)
+            o.rotation.set(transform.rotation.x, transform.rotation.y, transform.rotation.z);
+        if (transform.scale)
+            o.scale.set(transform.scale.x, transform.scale.y, transform.scale.z);
+        this.emitTransformChanged(uuid);
+        return true;
+    }
+    emitTransformChanged(uuid) {
+        const transform = this.getObject3DTransform(uuid);
+        if (transform) {
+            this.object3DTransformChanged$.next({ uuid, ...transform });
+        }
+    }
+    //
+    // ---------- Gizmo ----------
+    //
+    /** Creates the mp.transformControls node of a model and wires it (events, snap) */
+    createGizmo(uuid, modelNode, sceneObject, mode, visible, node) {
+        const gizmoNode = node ?? sceneObject.addNode();
+        const component = gizmoNode.addComponent('mp.transformControls');
+        gizmoNode.start();
+        const tc = component.transformControls;
+        tc.visible = visible;
+        component.inputs.selection = modelNode;
+        component.inputs.mode = mode;
+        modelNode.obj3D.controls = component;
+        const entry = {
+            uuid,
+            node: gizmoNode,
+            component,
+            mode,
+            dragStart: null,
+            lastPosition: modelNode.obj3D.position.clone(),
+            onDraggingChanged: (event) => {
+                entry.dragStart = event?.value ? modelNode.obj3D.position.clone() : null;
+                entry.lastPosition = modelNode.obj3D.position.clone();
+            },
+            onObjectChange: () => this.onGizmoObjectChange(entry, modelNode),
+        };
+        if (typeof tc.addEventListener === 'function') {
+            tc.addEventListener('dragging-changed', entry.onDraggingChanged);
+            tc.addEventListener('objectChange', entry.onObjectChange);
+        }
+        this.applySnap(tc);
+        this.gizmos.set(uuid, entry);
+        this.activeGizmoUuid = uuid;
+        return entry;
+    }
+    /** Keeps a translate drag within maxDragDistance / maxDragHeight of where it started, then notifies */
+    onGizmoObjectChange(entry, modelNode) {
+        const pos = modelNode.obj3D.position;
+        if (entry.mode === 'translate') {
+            const start = entry.dragStart ?? entry.lastPosition;
+            const delta = pos.clone().sub(start);
+            delta.y = MathUtils.clamp(delta.y, -this.maxDragHeight, this.maxDragHeight);
+            const length = delta.length();
+            if (length > this.maxDragDistance) {
+                delta.multiplyScalar(this.maxDragDistance / length);
+            }
+            pos.copy(start).add(delta);
+        }
+        entry.lastPosition = pos.clone();
+        this.emitTransformChanged(entry.uuid);
+    }
+    applySnap(tc) {
+        if (!tc)
+            return;
+        const snap = this.gizmoSnap;
+        const translation = snap?.translation ?? null;
+        const rotation = snap?.rotationDeg != null ? MathUtils.degToRad(snap.rotationDeg) : null;
+        const scale = snap?.scale ?? null;
+        if (typeof tc.setTranslationSnap === 'function')
+            tc.setTranslationSnap(translation);
+        else
+            tc.translationSnap = translation;
+        if (typeof tc.setRotationSnap === 'function')
+            tc.setRotationSnap(rotation);
+        else
+            tc.rotationSnap = rotation;
+        if (typeof tc.setScaleSnap === 'function')
+            tc.setScaleSnap(scale);
+        else
+            tc.scaleSnap = scale;
+    }
+    /**
+     * Shows the transform gizmo on an object (any previous gizmo is detached first).
+     * Re-attaching to the object that already has the gizmo only changes its mode.
+     */
+    async attachGizmo(uuid, mode, sdk) {
+        const modelNode = this.dictionnaryObjects3D.get(uuid);
+        const sceneObject = this.dictionnarySceneObjects3D.get(uuid);
+        if (!modelNode || !sceneObject)
+            return false;
+        const existing = this.gizmos.get(uuid);
+        if (existing && this.activeGizmoUuid === uuid) {
+            this.setGizmoMode(mode);
+            return true;
+        }
+        // A started scene object refuses new nodes (addNode returns null): use a dedicated one
+        let node = sceneObject.addNode();
+        let gizmoSceneObject = null;
+        if (!node) {
+            if (!sdk?.Scene)
+                return false;
+            [gizmoSceneObject] = await sdk.Scene.createObjects(1);
+            node = gizmoSceneObject.addNode();
+        }
+        this.detachGizmo();
+        const entry = this.createGizmo(uuid, modelNode, sceneObject, mode, true, node);
+        entry.sceneObject = gizmoSceneObject;
+        this.lastObject3D = modelNode.obj3D;
+        return true;
+    }
+    /** Switches the active gizmo between translate / rotate / scale without re-attaching it */
+    setGizmoMode(mode) {
+        const entry = this.activeGizmoUuid ? this.gizmos.get(this.activeGizmoUuid) : null;
+        if (!entry)
+            return;
+        entry.mode = mode;
+        entry.dragStart = null;
+        entry.component.inputs.mode = mode;
+        const tc = entry.component.transformControls;
+        if (tc && typeof tc.setMode === 'function')
+            tc.setMode(mode);
+    }
+    /** Really removes the gizmo from the scene (default: the active one) */
+    detachGizmo(uuid) {
+        const id = uuid ?? this.activeGizmoUuid;
+        if (!id)
+            return;
+        const entry = this.gizmos.get(id);
+        if (!entry)
+            return;
+        const tc = entry.component?.transformControls;
+        if (tc) {
+            if (typeof tc.removeEventListener === 'function') {
+                tc.removeEventListener('dragging-changed', entry.onDraggingChanged);
+                tc.removeEventListener('objectChange', entry.onObjectChange);
+            }
+            tc.visible = false;
+            if (typeof tc.detach === 'function')
+                tc.detach();
+            if (typeof tc.dispose === 'function')
+                tc.dispose();
+            if (tc.parent && typeof tc.parent.remove === 'function')
+                tc.parent.remove(tc);
+        }
+        try {
+            entry.node.stop();
+        }
+        catch { /* already stopped */ }
+        try {
+            entry.sceneObject?.stop();
+        }
+        catch { /* already stopped */ }
+        const modelNode = this.dictionnaryObjects3D.get(id);
+        if (modelNode?.obj3D)
+            modelNode.obj3D.controls = null;
+        this.gizmos.delete(id);
+        if (this.activeGizmoUuid === id)
+            this.activeGizmoUuid = null;
+    }
+    isGizmoAttached(uuid) {
+        return uuid ? this.gizmos.has(uuid) : this.activeGizmoUuid !== null;
+    }
+    /** Snap steps for all gizmos (null / missing value = no snap) */
+    setGizmoSnap(snap) {
+        this.gizmoSnap = snap ? { ...snap } : null;
+        this.gizmos.forEach((entry) => this.applySnap(entry.component?.transformControls));
+    }
+    setGizmoMaxDragDistance(maxDistance, maxHeight) {
+        if (maxDistance > 0)
+            this.maxDragDistance = maxDistance;
+        if (maxHeight !== undefined && maxHeight > 0)
+            this.maxDragHeight = maxHeight;
+    }
+    /**
+     * Prevents camera navigation to other sweeps while a gizmo is edited.
+     * The SDK has no "freeze camera" switch, so every enabled sweep except the current one is
+     * disabled (Sweep.disable); exactly those sweeps are re-enabled on unlock. Sweeps already
+     * disabled (forbidden sweeps, edit mode) are never touched, and `keepDisabled` lists sweeps
+     * that must stay disabled on unlock.
+     * @returns false when the lock could not be applied (SDK without Sweep.disable, unknown current sweep)
+     */
+    async setNavigationLocked(sdk, locked, sweepCollection, currentSweepId, keepDisabled = []) {
+        if (!sdk?.Sweep || typeof sdk.Sweep.disable !== 'function' || typeof sdk.Sweep.enable !== 'function') {
+            return false;
+        }
+        if (locked) {
+            if (this.sweepsDisabledByLock.length > 0)
+                return true;
+            if (!sweepCollection || !currentSweepId)
+                return false;
+            // a sweep this lock re-enabled just before may still be reported disabled by the SDK
+            const ids = Object.keys(sweepCollection).filter((sid) => sid !== currentSweepId &&
+                (sweepCollection[sid]?.enabled !== false || this.sweepsEnabledByUnlock.includes(sid)));
+            if (ids.length === 0)
+                return true;
+            try {
+                await sdk.Sweep.disable(...ids);
+                this.sweepsDisabledByLock = ids;
+            }
+            catch {
+                // fall back to one call per sweep to know exactly which ones were disabled
+                const results = await Promise.allSettled(ids.map((sid) => sdk.Sweep.disable(sid)));
+                this.sweepsDisabledByLock = ids.filter((_, i) => results[i].status === 'fulfilled');
+            }
+            return true;
+        }
+        const toEnable = this.sweepsDisabledByLock.filter((sid) => !keepDisabled.includes(sid));
+        this.sweepsDisabledByLock = [];
+        this.sweepsEnabledByUnlock = toEnable;
+        if (toEnable.length > 0) {
+            try {
+                await sdk.Sweep.enable(...toEnable);
+            }
+            catch {
+                await Promise.allSettled(toEnable.map((sid) => sdk.Sweep.enable(sid)));
+            }
+        }
+        return true;
+    }
+    isNavigationLocked() {
+        return this.sweepsDisabledByLock.length > 0;
+    }
+    /** Sweeps currently disabled by the navigation lock */
+    getSweepsDisabledByLock() {
+        return [...this.sweepsDisabledByLock];
+    }
+    /**
+     * Legacy API: attaches a gizmo to a model node. Prefer attachGizmo(uuid, mode).
+     */
     async attachGizmoControlTo3DObject(sdk, modelNode, sceneObject, mode, visible, isNewObject) {
         let node = sceneObject.addNode();
         if (!node) {
             const [newSceneObject] = await sdk.Scene.createObjects(1);
             node = newSceneObject.addNode();
         }
-        const myControl = node.addComponent('mp.transformControls');
-        node.start();
-        myControl.transformControls.visible = visible;
-        myControl.inputs.selection = modelNode;
-        myControl.inputs.mode = mode;
-        modelNode.obj3D.controls = myControl;
-        if (isNewObject) {
-            if (!this.lastObject3D || !this.lastObject3D.controls) {
-                try {
-                    modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;
-                }
-                catch (e) {
-                    console.log(`id obj in Scene was not assigned to id from DB`);
-                }
-                this.lastObject3D = modelNode.obj3D;
+        if (isNewObject && (!this.lastObject3D || !this.lastObject3D.controls)) {
+            try {
+                modelNode.obj3D.uuid = this.lastObject3D.uuid || this.lastObject3D.id;
+            }
+            catch (e) {
+                // lastObject3D is not set: the model keeps its own uuid
             }
         }
-        else {
-            this.lastObject3D = modelNode.obj3D;
-        }
+        this.detachGizmo();
+        this.createGizmo(modelNode.obj3D.uuid, modelNode, sceneObject, mode, visible, node);
+        this.lastObject3D = modelNode.obj3D;
         return modelNode;
     }
+    /** Removes the gizmo of the last added / edited object */
     removeGizmoFromLastObject() {
-        if (this.lastObject3D && this.lastObject3D.controls) {
-            this.lastObject3D.controls.transformControls.visible = false;
-            this.lastObject3D.controls.transformControls.dispose();
-            this.lastObject3D.controls = null;
+        const last = this.lastObject3D;
+        if (!last)
+            return;
+        const uuid = last.uuid ?? last.id;
+        if (uuid && this.gizmos.has(uuid)) {
+            this.detachGizmo(uuid);
+        }
+        else if (last.controls) {
+            // gizmo not created by this service: best effort
+            last.controls.transformControls.visible = false;
+            last.controls.transformControls.dispose();
+            last.controls = null;
         }
     }
-    toggleViewFrustum() {
-        if (this.securityCameraAnimator) {
+    //
+    // ---------- Security camera ----------
+    //
+    applyViewFrustum(uuid, visible) {
+        const animator = this.securityCameraAnimators.get(uuid);
+        if (!animator)
+            return false;
+        const current = this.viewFrustumVisible.get(uuid) ?? true;
+        if (current === visible)
+            return true;
+        try {
+            animator.toggleViewFrustum();
+        }
+        catch {
+            return false;
+        }
+        this.viewFrustumVisible.set(uuid, visible);
+        return true;
+    }
+    /** Shows / hides the view frustum of the security camera `uuid` */
+    setViewFrustum(uuid, visible) {
+        return this.applyViewFrustum(uuid, visible);
+    }
+    isViewFrustumVisible(uuid) {
+        return this.viewFrustumVisible.get(uuid) ?? false;
+    }
+    /** Toggles the frustum of `uuid`, or of the last loaded security camera when omitted */
+    toggleViewFrustum(uuid) {
+        const id = uuid ?? this.lastSecurityCameraUuid;
+        if (id && this.securityCameraAnimators.has(id)) {
+            this.applyViewFrustum(id, !(this.viewFrustumVisible.get(id) ?? true));
+        }
+        else if (!uuid && this.securityCameraAnimator) {
+            // animator set by hand (legacy)
             this.securityCameraAnimator.toggleViewFrustum();
         }
     }
     clear() {
+        Array.from(this.gizmos.keys()).forEach((id) => this.detachGizmo(id));
         this.dictionnaryObjects3D.clear();
         this.dictionnarySceneObjects3D.clear();
+        this.loaderComponents.clear();
+        this.securityCameraAnimators.clear();
+        this.viewFrustumVisible.clear();
+        this.lastSecurityCameraUuid = null;
+        this.sweepsDisabledByLock = [];
         this.lastObject3D = null;
         this.azimuthalCrown = null;
         this.securityCameraAnimator = null;
@@ -4039,11 +4688,11 @@ class MatterportTagService {
      * floor and room context. Must be called after each sweep, floor or mode change.
      *
      * Rules:
-     *  - DOLLHOUSE / FLOORPLAN → all tags hidden (opacity 0).
-     *  - INSIDE → only tags whose sweep belongs to the current floor are shown;
-     *    proximity-based opacity is applied via computeTagOpacity().
-     *    Tags on other floors are hidden (opacity 0).
-     *  - TRANSITIONING → no change (skip update to avoid flickering).
+     *  - A tag shows when its sweep is on the floor being displayed, in every mode. Tags on
+     *    other floors are hidden (opacity 0) and cannot be opened.
+     *  - While all floors are displayed - the usual state of DOLLHOUSE and FLOORPLAN - every
+     *    tag shows.
+     *  - A tag with no sweep belongs to no floor and always shows.
      *
      * @param sdk          Matterport SDK instance.
      * @param poseCamera   Current camera pose.
@@ -4055,7 +4704,12 @@ class MatterportTagService {
         if (!sdk || this.dictionnaryTags.size === 0)
             return;
         const isInteriorMode = currentCameraMode === CameraMode.INSIDE;
-        const currentFloorId = currentFloorSequence !== null ? currentFloorSequence.toString() : null;
+        // The SDK reports sequence -1 while all floors are displayed, which is the dollhouse's and the
+        // floor plan's normal state. That is "no floor in particular", not a floor that no tag is on:
+        // read as a floor id, it matched nothing and hid every tag that has a sweep.
+        const currentFloorId = currentFloorSequence !== null && currentFloorSequence >= 0
+            ? currentFloorSequence.toString()
+            : null;
         const promises = [];
         for (const [tagId, mattertagData] of this.dictionnaryTags) {
             if (tagId === mattertagToFollow)
@@ -4361,6 +5015,8 @@ class Config {
     constructor() { }
 }
 
+/** Pointer intersections a 3D object can be placed on (Pointer.Colliders MODEL and SWEEP) */
+const PLACEMENT_SURFACES = ['intersectedobject.model', 'intersectedobject.sweep'];
 class MatterportService {
     sdkKey;
     router;
@@ -4381,6 +5037,18 @@ class MatterportService {
     isMeasureModeOn = false;
     interactionMode = ViewerInteractions.DEFAULT;
     cameraMode = 'INSIDE';
+    /** Emitted when a placement (tag following the cursor, or 3D object preview) is cancelled by right click or Escape */
+    placementCancelled$ = new Subject();
+    /** Pending interactive placement of a 3D object (see startObject3DPlacement) */
+    object3DPlacement = null;
+    /** Sweeps snapshot taken when navigation is locked (disabled sweeps vanish from Sweep.data) */
+    lockedSweepsSnapshot = {};
+    /**
+     * Every sweep seen in Sweep.data. After an unlock the SDK re-emits the re-enabled sweeps little by
+     * little: a lock asked meanwhile must still know all of them (it found nothing to disable).
+     */
+    knownSweeps = {};
+    keydownTargets = [];
     get mattertagIDs() {
         return this.matterportTagService.mattertagIDs;
     }
@@ -4522,6 +5190,10 @@ class MatterportService {
      * Actions on left click when positioning mattertag in visit
      */
     pointerLeftClickHandler = (evt) => {
+        if (this.object3DPlacement) {
+            this.validateObject3DPlacement();
+            return;
+        }
         if (this.mattertagToFollow) {
             const mattertagData = this.dictionnaryTags.get(this.mattertagToFollow);
             if (mattertagData) {
@@ -4535,8 +5207,7 @@ class MatterportService {
     };
     pointerRightClickHandler = (e) => {
         e.preventDefault();
-        this.cancelFollowingCursor();
-        alert('action cancelled');
+        this.cancelCurrentPlacement();
     };
     pointerMiddleClickHandler = (e) => {
         this.pointerService.updateCursorDisplay(this.poseMatterport);
@@ -4583,6 +5254,7 @@ class MatterportService {
                 onRightClick: this.pointerRightClickHandler.bind(this),
                 onMiddleClick: this.pointerMiddleClickHandler.bind(this),
             });
+            this.registerEscapeListener(iframe);
             // Load SDK
             const showcaseWindow = iframe.contentWindow;
             iframe.addEventListener('load', async () => {
@@ -4659,6 +5331,9 @@ class MatterportService {
                         // (we are about to validate, but it exists in sdk already)
                         this.enable_following_tag(this.mattertagToFollow);
                     }
+                    if (this.object3DPlacement) {
+                        this.updateObject3DPlacementPreview(intersection);
+                    }
                     if (this.pointerService) {
                         this.pointerService.setCursorPositionButtonDisplayed(false);
                     }
@@ -4684,6 +5359,11 @@ class MatterportService {
                 // subscribe to sweeps
                 this.sdk.Sweep.data.subscribe({
                     onCollectionUpdated: function subscr(collection) {
+                        this.knownSweeps = { ...this.knownSweeps, ...collection };
+                        if (this.object3DService.isNavigationLocked()) {
+                            // sweeps disabled by the lock are no longer in the collection: keep them known
+                            collection = { ...this.lockedSweepsSnapshot, ...collection };
+                        }
                         this.sweeps = Object.keys(collection);
                         this.sweepCollection = collection;
                         // Rebuild sid ↔ uuid maps whenever the collection updates
@@ -4795,7 +5475,7 @@ class MatterportService {
                 // Pointer trick
                 // Create a div that will appear when the cursor is still
                 // It will intercept the click of the mouse before it trigerring the Matterport's tour navigation
-                this.pointerService.startPointerTrick(this.sdk, this.container, () => this.poseMatterport, () => this.poseCamera, () => this.interactionMode, () => this.mattertagToFollow);
+                this.pointerService.startPointerTrick(this.sdk, this.container, () => this.poseMatterport, () => this.poseCamera, () => this.interactionMode, () => this.getFollowTarget());
                 /**
                 * Transitions
                 */
@@ -4867,7 +5547,7 @@ class MatterportService {
      * Styling of pointer
      */
     updatePointerTrick() {
-        this.pointerService.updatePointerTrick(this.sdk, this.container, this.poseMatterport, this.poseCamera, this.interactionMode, this.mattertagToFollow);
+        this.pointerService.updatePointerTrick(this.sdk, this.container, this.poseMatterport, this.poseCamera, this.interactionMode, this.getFollowTarget());
     }
     /**
      * Triggers a tag visibility refresh based on current camera mode, floor and sweep.
@@ -5296,6 +5976,9 @@ class MatterportService {
      * @param uuid
      */
     async deleteObject3D(uuid) {
+        if (this.object3DPlacement?.uuid === uuid) {
+            this.cancelObject3DPlacement();
+        }
         return this.object3DService.deleteObject3D(uuid);
     }
     getObject3DModelNodeFromDictionnary(uuid) {
@@ -5340,6 +6023,11 @@ class MatterportService {
      * Cancels following of cursor (meaning deleting last Mattertag)
      */
     cancelFollowingCursor() {
+        if (this.object3DPlacement) {
+            // generic cancel (toolbox buttons...) while a 3D object follows the cursor
+            this.cancelObject3DPlacement();
+            return;
+        }
         this.deleteLastMattertag();
         this.setInteractionMode(ViewerInteractions.DEFAULT);
     }
@@ -5708,7 +6396,10 @@ class MatterportService {
      * Clear all variables, deletes all tags (when viewer is remover or model changed=reload needed)
      */
     async clearAll() {
-        console.log('removing viewer');
+        this.cancelObject3DPlacement();
+        this.removeEscapeListener();
+        this.lockedSweepsSnapshot = {};
+        this.knownSweeps = {};
         this.clearViewSubscriptions();
         this.viewsByType.clear();
         this.currentView = null;
@@ -5732,6 +6423,9 @@ class MatterportService {
     async init3DObjectViewer() {
         return this.object3DService.init3DObjectViewer(this.sdk);
     }
+    /**
+     * Adds a 3D model; resolves once it is loaded, rejects on unknown format or load timeout (~15 s).
+     */
     async add3DObject(obj, mode) {
         return this.object3DService.add3DObject(this.sdk, obj, mode);
     }
@@ -5741,7 +6435,43 @@ class MatterportService {
     isObjectVisible(objectId) {
         return this.object3DService.isObjectVisible(objectId);
     }
-    async pointCameraTo3DObject(objectId) {
+    /** Moves the camera to the object (centered on its bounding box). Resolves false when the object is unknown. */
+    /**
+     * Moves the camera to the sweep closest to a 3D object and turns it toward the object.
+     * @param visibleArea client X bounds of the part of the viewer not covered by other panels
+     *                    (the lateral menu covers the right of the viewer): the object is centered there.
+     * Falls back to the temporary tag navigation when no sweep can be used.
+     */
+    async pointCameraTo3DObject(objectId, visibleArea) {
+        const box = this.object3DService.getObject3DBoundingBox(objectId);
+        const sweep = box ? this.findNearestSweep(box.center) : null;
+        const sweepData = sweep ? { ...this.lockedSweepsSnapshot, ...(this.sweepCollection ?? {}) }[sweep.sid] : null;
+        if (box && sweepData?.position && this.sdk?.Sweep) {
+            const projection = this.poseCamera?.projection;
+            const tanHalfFov = projection?.[0] ? 1 / projection[0] : 1;
+            let screenX = 0;
+            const viewer = document.querySelector('#viewer-module');
+            if (visibleArea && viewer) {
+                const rect = viewer.getBoundingClientRect();
+                screenX = visibleCenterScreenX(rect, visibleArea.left, visibleArea.right);
+            }
+            const rotation = computeFramingRotation(sweepData.position, box.center, tanHalfFov, screenX);
+            try {
+                if (this.poseCamera?.sweep === sweep.sid) {
+                    await this.sdk.Camera.setRotation(rotation, { speed: 80 });
+                }
+                else {
+                    await this.sdk.Sweep.moveTo(sweep.sid, {
+                        rotation,
+                        transition: this.sdk.Sweep.Transition?.FLY,
+                    });
+                }
+                return true;
+            }
+            catch (error) {
+                // disabled or unreachable sweep: use the tag navigation below
+            }
+        }
         return this.object3DService.pointCameraTo3DObject(this.sdk, objectId, this.createMattertagFromPOI.bind(this), this.goToTag.bind(this), this.deleteLastMattertag.bind(this), this.getTagFromElementId.bind(this));
     }
     getSceneNodeFromObject3DId(uuid) {
@@ -5756,31 +6486,275 @@ class MatterportService {
     removeGizmoFromLastObject() {
         this.object3DService.removeGizmoFromLastObject();
     }
-    toggleViewFrustum() {
-        this.object3DService.toggleViewFrustum();
+    /** Toggles the frustum of the security camera `uuid` (default: the last loaded one) */
+    toggleViewFrustum(uuid) {
+        this.object3DService.toggleViewFrustum(uuid);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, deps: [{ token: 'config' }, { token: MATTERPORT_SDK_KEY }, { token: i1$1.Router }, { token: i1$1.ActivatedRoute }, { token: BaseVisibilityService }, { token: i0.NgZone }, { token: MatterportMeasurementService }, { token: MatterportNavigationService }, { token: MatterportPointerService }, { token: MatterportObject3DService }, { token: MatterportTagService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: Config, decorators: [{
-                    type: Inject,
-                    args: ['config']
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [MATTERPORT_SDK_KEY]
-                }] }, { type: i1$1.Router }, { type: i1$1.ActivatedRoute }, { type: BaseVisibilityService }, { type: i0.NgZone }, { type: MatterportMeasurementService }, { type: MatterportNavigationService }, { type: MatterportPointerService }, { type: MatterportObject3DService }, { type: MatterportTagService }] });
-
-/**
- * Builds an orthonormal frame from three points, or null when they are (nearly) collinear.
- *
- * Three points define a plane, and a plane plus an origin defines an orientation. Collinear points
- * do not: they leave the rotation about their common line undetermined, which is why the caller has
- * to reject them rather than produce a confident wrong answer.
+    setViewFrustum(uuid, visible) {
+        return this.object3DService.setViewFrustum(uuid, visible);
+    }
+    isViewFrustumVisible(uuid) {
+        return this.object3DService.isViewFrustumVisible(uuid);
+    }
+    //
+    // ---------- 3D objects: geometry, transform, gizmo ----------
+    //
+    /** Emits on gizmo changes and on setObject3DTransform / placeObject3DOnSurface / normalizeObject3DSize */
+    get object3DTransformChanged$() {
+        return this.object3DService.object3DTransformChanged$;
+    }
+    /** World-space bounding box, null when the object is unknown or not loaded */
+    getObject3DBoundingBox(uuid) {
+        return this.object3DService.getObject3DBoundingBox(uuid);
+    }
+    /** Dimensions of the model in meters, without its rotation */
+    getObject3DDimensions(uuid) {
+        return this.object3DService.getObject3DDimensions(uuid);
+    }
+    /** Uniform scale so the largest dimension equals `targetSizeMeters`; returns the new scale or null */
+    normalizeObject3DSize(uuid, targetSizeMeters) {
+        return this.object3DService.normalizeObject3DSize(uuid, targetSizeMeters);
+    }
+    /** Moves the object so its bounding box bottom-center (top-center on a ceiling) lies on `point` */
+    placeObject3DOnSurface(uuid, point, normal, frontYawOffset = 0) {
+        return this.object3DService.placeObject3DOnSurface(uuid, point, normal, frontYawOffset);
+    }
+    getObject3DTransform(uuid) {
+        return this.object3DService.getObject3DTransform(uuid);
+    }
+    /** Rotation in radians */
+    setObject3DTransform(uuid, transform) {
+        return this.object3DService.setObject3DTransform(uuid, transform);
+    }
+    attachGizmo(uuid, mode) {
+        return this.object3DService.attachGizmo(uuid, mode, this.sdk);
+    }
+    setGizmoMode(mode) {
+        this.object3DService.setGizmoMode(mode);
+    }
+    detachGizmo(uuid) {
+        this.object3DService.detachGizmo(uuid);
+    }
+    isGizmoAttached(uuid) {
+        return this.object3DService.isGizmoAttached(uuid);
+    }
+    /** null disables snapping (default) */
+    setGizmoSnap(snap) {
+        this.object3DService.setGizmoSnap(snap);
+    }
+    /** Limits of a translate drag from its start (default 2 m, +/- 1.5 m vertically) */
+    setGizmoMaxDragDistance(maxDistance, maxHeight) {
+        this.object3DService.setGizmoMaxDragDistance(maxDistance, maxHeight);
+    }
+    /**
+     * Locks / unlocks camera navigation to other sweeps while a gizmo is edited: every enabled sweep
+     * except the current one is disabled, and exactly those are re-enabled on unlock.
+     * @returns false when the lock could not be applied (SDK not ready, current sweep unknown)
+     */
+    async setNavigationLocked(locked) {
+        if (!this.sdk)
+            return false;
+        const currentSweep = this.poseCamera?.sweep ?? null;
+        const sweeps = { ...this.knownSweeps, ...(this.sweepCollection ?? {}) };
+        if (locked && !this.object3DService.isNavigationLocked()) {
+            this.lockedSweepsSnapshot = sweeps;
+        }
+        const keepDisabled = (this.forbiddenSweeps ?? []).map((s) => this.navigationService.resolveSweepSid(s));
+        const done = await this.object3DService.setNavigationLocked(this.sdk, locked, sweeps, currentSweep, keepDisabled);
+        if (!locked || !done) {
+            this.lockedSweepsSnapshot = {};
+        }
+        return done;
+    }
+    isNavigationLocked() {
+        return this.object3DService.isNavigationLocked();
+    }
+    //
+    // ---------- 3D objects: interactive placement ----------
+    //
+    /**
+     * Makes an already loaded model follow the cursor on the surfaces of the visit.
+     * Left click resolves with the surface point / normal under the cursor (read the object origin
+     * with getObject3DTransform); right click or Escape hides the model and resolves null
+     * (deleting it is up to the caller). Resolves null right away if another interaction is running.
+     */
+    startObject3DPlacement(uuid, options = {}) {
+        if (!this.object3DService.getObject3DModelNodeFromDictionnary(uuid)) {
+            return Promise.resolve(null);
+        }
+        if (this.object3DPlacement) {
+            this.cancelObject3DPlacement();
+        }
+        if (this.interactionMode !== ViewerInteractions.DEFAULT) {
+            return Promise.resolve(null);
+        }
+        return new Promise((resolve) => {
+            this.object3DPlacement = { uuid, resolve, lastPoint: null, lastNormal: null, frontYawOffset: options.frontYawOffset ?? 0 };
+            this.object3DService.setObject3DColliderEnabled(uuid, false);
+            this.object3DService.setObject3DVisible(uuid, false);
+            this.setInteractionMode(ViewerInteractions.PLACING_OBJECT3D);
+            if (this.poseMatterport?.position) {
+                this.updateObject3DPlacementPreview(this.poseMatterport);
+            }
+        });
+    }
+    isPlacingObject3D() {
+        return !!this.object3DPlacement;
+    }
+    /** Cancels the running object placement (model hidden, promise resolves null) */
+    cancelObject3DPlacement() {
+        const placement = this.object3DPlacement;
+        if (!placement)
+            return;
+        this.endObject3DPlacement();
+        this.object3DService.setObject3DVisible(placement.uuid, false);
+        placement.resolve(null);
+    }
+    /**
+     * Drops the object where it is previewed (same as a left click). Touch screens have no hover: each
+     * tap moves the preview, and the app confirms with a button.
+     * @returns false when no surface was pointed yet
+     */
+    confirmObject3DPlacement() {
+        if (!this.object3DPlacement?.lastPoint)
+            return false;
+        this.validateObject3DPlacement();
+        return true;
+    }
+    /** True once the preview stands on a surface (the placement can be confirmed) */
+    hasObject3DPlacementPoint() {
+        return !!this.object3DPlacement?.lastPoint;
+    }
+    validateObject3DPlacement() {
+        const placement = this.object3DPlacement;
+        if (!placement || !placement.lastPoint)
+            return; // no surface under the cursor yet
+        this.endObject3DPlacement();
+        placement.resolve({
+            position: placement.lastPoint,
+            normal: placement.lastNormal ?? { x: 0, y: 1, z: 0 },
+        });
+    }
+    endObject3DPlacement() {
+        const placement = this.object3DPlacement;
+        if (!placement)
+            return;
+        this.object3DPlacement = null;
+        this.object3DService.setObject3DColliderEnabled(placement.uuid, true);
+        this.setInteractionMode(ViewerInteractions.DEFAULT);
+    }
+    updateObject3DPlacementPreview(intersection) {
+        const placement = this.object3DPlacement;
+        if (!placement || !intersection?.position)
+            return;
+        // Only the scanned surfaces: hitting the preview itself (reported as "unknown") would push it away
+        // along the ray at each move, until it lands kilometers from the camera
+        if (typeof intersection.object === 'string' && !PLACEMENT_SURFACES.includes(intersection.object))
+            return;
+        const point = { x: intersection.position.x, y: intersection.position.y, z: intersection.position.z };
+        const normal = intersection.normal
+            ? { x: intersection.normal.x, y: intersection.normal.y, z: intersection.normal.z }
+            : { x: 0, y: 1, z: 0 };
+        if (!placement.lastPoint) {
+            // hidden until it is on a surface (it was loaded at the camera position)
+            this.object3DService.setObject3DVisible(placement.uuid, true);
+        }
+        placement.lastPoint = point;
+        placement.lastNormal = normal;
+        this.object3DService.placeObject3DOnSurface(placement.uuid, point, normal, placement.frontYawOffset);
+    }
+    /** Token for the pointer trick: truthy while something follows the cursor (tag or 3D object) */
+    getFollowTarget() {
+        return this.mattertagToFollow ?? this.object3DPlacement?.uuid ?? null;
+    }
+    /**
+     * Cancels whatever follows the cursor (right click / Escape): the 3D object preview, or the tag.
+     * Emits placementCancelled$ when something was actually running.
+     */
+    cancelCurrentPlacement() {
+        const wasRunning = this.interactionMode !== ViewerInteractions.DEFAULT || !!this.object3DPlacement;
+        // nothing follows the cursor: a plain right click must not remove the last (existing) tag
+        if (!wasRunning)
+            return;
+        if (this.object3DPlacement) {
+            this.cancelObject3DPlacement();
+        }
+        else {
+            this.cancelFollowingCursor();
+        }
+        this.placementCancelled$.next();
+    }
+    /** Escape cancels any placement. Listens on the page and on the (same-origin) Showcase iframe, which takes the focus on click. */
+    registerEscapeListener(iframe) {
+        this.removeEscapeListener();
+        const handler = (e) => {
+            if (e.key !== 'Escape')
+                return;
+            if (this.interactionMode !== ViewerInteractions.DEFAULT || this.object3DPlacement) {
+                this.cancelCurrentPlacement();
+            }
+        };
+        const targets = [document];
+        try {
+            if (iframe?.contentWindow)
+                targets.push(iframe.contentWindow);
+        }
+        catch { /* cross-origin iframe: page listener only */ }
+        targets.forEach((target) => {
+            target.addEventListener('keydown', handler);
+            this.keydownTargets.push({ target, handler });
+        });
+    }
+    removeEscapeListener() {
+        this.keydownTargets.forEach(({ target, handler }) => target.removeEventListener('keydown', handler));
+        this.keydownTargets = [];
+    }
+    ngOnDestroy() {
+        this.cancelObject3DPlacement();
+        this.removeEscapeListener();
+    }
+    //
+    // ---------- Sweeps ----------
+    //
+    /**
+     * Closest enabled sweep to a world position (for instance to re-assign the zone of a moved object).
+     * `sweepId` is the DB-format id (like currentSweep), `sid` the SDK id. null when no sweep is known.
+     */
+    findNearestSweep(position) {
+        const collection = { ...this.lockedSweepsSnapshot, ...(this.sweepCollection ?? {}) };
+        const sids = Object.keys(collection).filter((sid) => collection[sid]?.position && collection[sid].enabled !== false);
+        const best = pickNearestSweepOnSameStorey(sids.map((sid) => ({ sid, position: collection[sid].position, floorY: sweepFloorY(collection[sid]) })), position);
+        const data = best ? collection[best] : null;
+        if (!best)
+            return null;
+        return {
+            sweepId: this.navigationService.resolveSweepUuid(best),
+            sid: best,
+            floorSequence: data.floorInfo?.sequence ?? (typeof data.floor === 'number' ? data.floor : null),
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, deps: [{ token: 'config' }, { token: MATTERPORT_SDK_KEY }, { token: i1$1.Router }, { token: i1$1.ActivatedRoute }, { token: BaseVisibilityService }, { token: i0.NgZone }, { token: MatterportMeasurementService }, { token: MatterportNavigationService }, { token: MatterportPointerService }, { token: MatterportObject3DService }, { token: MatterportTagService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: Config, decorators: [{
+                    type: Inject,
+                    args: ['config']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MATTERPORT_SDK_KEY]
+                }] }, { type: i1$1.Router }, { type: i1$1.ActivatedRoute }, { type: BaseVisibilityService }, { type: i0.NgZone }, { type: MatterportMeasurementService }, { type: MatterportNavigationService }, { type: MatterportPointerService }, { type: MatterportObject3DService }, { type: MatterportTagService }] });
+
+/**
+ * Builds an orthonormal frame from three points, or null when they are (nearly) collinear.
+ *
+ * Three points define a plane, and a plane plus an origin defines an orientation. Collinear points
+ * do not: they leave the rotation about their common line undetermined, which is why the caller has
+ * to reject them rather than produce a confident wrong answer.
  */
 function frameFromPoints(a, b, c) {
     const e1 = b.clone().sub(a);
@@ -5895,6 +6869,15 @@ function solveReducedAlignment(pairs, up) {
         scale,
     };
 }
+/**
+ * The 3D viewers' background where there is nothing to draw, unless the app sets its own as
+ * --smarterplan-viewer-background: the SmarterPlan app's light blue, from the POC.
+ */
+const VIEWER_BACKGROUND = '#e0f7ff';
+/** The 3D viewers' background as the app sets it, where the element is. */
+function viewerBackground(element) {
+    return getComputedStyle(element).getPropertyValue('--smarterplan-viewer-background').trim() || VIEWER_BACKGROUND;
+}
 class ThreeJsService {
     ngZone;
     scene;
@@ -5913,6 +6896,17 @@ class ThreeJsService {
     objectClicked$ = new Subject();
     /** Emits when the user clicks a tag, mirroring Matterport's tag click. */
     tagClicked$ = new Subject();
+    /**
+     * Emits the tag the camera is sent to (goToTag): for a viewer drawing the model elsewhere, the
+     * splat viewer, to point it out.
+     */
+    tagFocused$ = new Subject();
+    /**
+     * Emits when the tags change - added, moved, removed, filtered, calibrated differently - at most
+     * once per turn of the event loop, however many changed in it.
+     */
+    tagsChanged$ = new Subject();
+    tagsChangeQueued = false;
     /** Emits a tag's label while the pointer is over it, and null when it leaves. */
     tagHovered$ = new Subject();
     // Tags live under the model rather than the scene, so the centering and scaling applied when the
@@ -5922,6 +6916,22 @@ class ThreeJsService {
     canvasResizeObserver;
     /** Aborts the in-flight model download. Parsing cannot be interrupted, only not started. */
     loadAbortController;
+    /**
+     * Which load is the wanted one. Every load takes the next number as it starts, and anything that
+     * makes it unwanted - another load, the scene being rebuilt, the viewer closing - moves the
+     * number on.
+     *
+     * Aborting the download is not enough to stop a load. A model read from the cache has no
+     * download to abort, and one that has finished downloading still has seconds of work ahead of it
+     * before it reaches the screen. A load that finds the number has moved on drops what it has.
+     */
+    loadGeneration = 0;
+    /** Whether the wanted load is still on its way, so abandoning it can say that it stopped. */
+    loadInProgress = false;
+    /** Whether a scene is up: started by init() and not yet taken down by destroy(). */
+    live = false;
+    /** Takes off each listener init() put on the canvas. */
+    canvasListeners = [];
     // The loaded base model, kept so tag placement can raycast against its geometry.
     modelRoot;
     /** True while the next click on the model places a tag instead of orbiting. */
@@ -5943,6 +6953,12 @@ class ThreeJsService {
      * placed in this one are told from those that came from elsewhere.
      */
     currentCaptureID = null;
+    /**
+     * Whether the visit on screen is the only one the site has. A tag records the visit it was placed
+     * in, but some do not - placed before that was recorded, or in the development model. With
+     * another visit around, such a tag is taken to come from it. With none, it can only be this one's.
+     */
+    soleVisit = false;
     /**
      * The model's surface as a grid: every cell some part of the surface passes through.
      *
@@ -5987,6 +7003,17 @@ class ThreeJsService {
     modelUp = 'y';
     /** While measuring: how many points and each segment's length. Null when it is abandoned. */
     measurementProgress$ = new Subject();
+    /**
+     * True when a measurement starts taking clicks, false when it stops - finished or abandoned. For a
+     * viewer drawing the model elsewhere, which takes the clicks itself; see addMeasurePointAtModelPoint.
+     */
+    measuringChanged$ = new Subject();
+    /**
+     * A measurement - under way or finished - was taken off the model. For a viewer drawing it
+     * elsewhere, the splat viewer: a finished one stays drawn while its form is open, which
+     * measurementProgress$ does not say the end of.
+     */
+    measurementCleared$ = new Subject();
     /**
      * Layer carrying the model alone, so the depth pick can render it without the tags.
      *
@@ -5994,8 +7021,18 @@ class ThreeJsService {
      * their parent passed, so marking the model's own meshes is enough - no re-parenting.
      */
     static PICK_LAYER = 1;
+    /** How large a tag is drawn, in CSS pixels. About what Matterport draws its own at. */
+    static TAG_SCREEN_PX = 28;
     /** The app's highlight colour, so a measurement reads as the active thing on screen. */
     static MEASURE_COLOR = '#FFB103';
+    /** Green for the points of a calibration that are settled, as opposed to the one in hand. */
+    static CALIBRATION_DONE_COLOR = '#1E9E5A';
+    /** Size on screen of the numbered pin left where a tag was matched: a little under a tag's. */
+    static CALIBRATION_PIN_PX = 24;
+    /** How long a mark just dropped takes to settle to its size, in milliseconds. */
+    static CONFIRM_PULSE_MS = 350;
+    /** How many matched tags a calibration takes. Three settle everything there is to settle. */
+    static CALIBRATION_PAIRS = 3;
     /** Cache Storage bucket holding downloaded models, and how many to keep. */
     static MODEL_CACHE = 'smarterplan-3d-models';
     static MODEL_CACHE_SIZE = 3;
@@ -6010,12 +7047,36 @@ class ThreeJsService {
     /** Translucent marker shown under the cursor while placing. */
     placementPreview;
     aligning = false;
+    /**
+     * True from the moment the calibration panel opens, before the walkthrough is armed: the tags
+     * from elsewhere are all on show, as they are while calibrating, so that what there is to
+     * calibrate with can be seen while reading what calibrating involves.
+     */
+    revealingCalibrationTags = false;
     alignmentPairs = [];
     alignmentSource = null;
     /** The tag `alignmentSource` was read from, kept so the same tag is not matched twice. */
     alignmentSourceTagId;
+    /**
+     * Everything drawn for the calibration under way: a numbered pin where each tag was matched, a
+     * line from the pin to its tag, and a ring round the tag being matched.
+     *
+     * A sibling of the tag group rather than a child of it. The points clicked are where the tags are
+     * to end up, in the frame the calibration maps onto (see pickAlignmentTarget) - not in the tags'
+     * own frame, which is the one about to change.
+     */
+    calibrationGroup = new THREE.Group();
+    /** Marks still settling after being dropped, advanced by the render loop. */
+    pulses = [];
     /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */
     alignmentProgress$ = new Subject();
+    /**
+     * Emits when a click during calibration did nothing, with what it was expected to land on.
+     *
+     * A click that changes nothing looks the same as a click that was not received. This lets the
+     * panel point at what it is waiting for instead.
+     */
+    alignmentClickIgnored$ = new Subject();
     /** In-flight camera move started by goToTag, advanced by the render loop. */
     cameraTween = null;
     /** Emits true while a heavy OBJ file is being parsed (in a worker, when available), false once done. */
@@ -6127,15 +7188,30 @@ class ThreeJsService {
         //    by then, so the model being abandoned would be handed to the scene built below.
         //  - The tag group, which is a field and keeps its sprites. They would be re-parented under the
         //    new model and show the previous visit's tags on it.
+        // Usually destroy() ran before this and there is nothing left to stop. When it did not, the
+        // scene before would carry on beside the one started below: its render loop drawing every
+        // frame as well, its model still on the graphics card, its listeners answering every click a
+        // second time.
+        if (this.live) {
+            this.destroy();
+        }
         this.discardCurrentLoad();
         this.clearTags();
         this.measuring = false;
         this.clearMeasurement();
+        // A calibration left half-done belongs to the scene it was started in: its points mean nothing
+        // in the next one, and left armed it would take that scene's first clicks for itself.
+        this.aligning = false;
+        this.revealingCalibrationTags = false;
+        this.soleVisit = false;
+        this.alignmentPairs = [];
+        this.clearAlignmentSource();
+        this.clearCalibrationMarks();
+        this.pulses = [];
         this.cameraTween = null;
-        this.modelRoot = undefined;
         // 1. Setup Scene
         this.scene = new THREE.Scene();
-        this.scene.background = new THREE.Color(0xe0f7ff); // from POC
+        this.scene.background = new THREE.Color(viewerBackground(canvas));
         // 2. Setup Camera
         this.camera = new THREE.PerspectiveCamera(75, canvas.clientWidth / canvas.clientHeight, 0.1, 10000);
         this.camera.position.set(0, 5, 10); // will be overridden later if passed
@@ -6180,7 +7256,14 @@ class ThreeJsService {
         // A light only contributes while it is part of the scene graph, and this one hangs off the camera.
         this.scene.add(this.camera);
         // 5. Setup Controls (from POC)
-        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        //
+        // Created outside Angular's zone, as is the pointer-move listener further down. The controls
+        // listen to every pointer move and wheel tick, and inside the zone each of those events had
+        // Angular re-check the whole page - dozens of times a second while the camera is dragged,
+        // competing with the frames being drawn - for a change that only ever concerns the canvas.
+        this.ngZone.runOutsideAngular(() => {
+            this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        });
         this.controls.rotateSpeed = 1.0;
         this.controls.dampingFactor = 0.1;
         this.controls.enableDamping = true;
@@ -6204,9 +7287,18 @@ class ThreeJsService {
                 }, 250);
             }
         });
-        // Interaction Event Listeners on canvas
-        canvas.addEventListener('click', this.onMouseClick.bind(this), false);
-        canvas.addEventListener('mousemove', this.onMouseMove.bind(this), false);
+        // Interaction Event Listeners on canvas. Kept so that destroy() can take them off again: the
+        // same canvas is used again when one 3D model is swapped for another, and a second set of
+        // listeners would answer every click twice.
+        const listen = (type, handler) => {
+            canvas.addEventListener(type, handler, false);
+            this.canvasListeners.push(() => canvas.removeEventListener(type, handler, false));
+        };
+        // A click changes what the page shows - a panel opens, a point is recorded - so Angular has to
+        // hear of it, wherever init() itself was called from.
+        listen('click', (event) => this.ngZone.run(() => this.onMouseClick(event)));
+        // Moving the pointer does not: it moves the ghost and the tooltip, both drawn here.
+        this.ngZone.runOutsideAngular(() => listen('mousemove', (event) => this.onMouseMove(event)));
         // Escape backs out of placement and calibration. On the window rather than the canvas, which
         // would need focus the user has no reason to have given it - they are aiming with the mouse.
         // Removed first because this service is a singleton: init() runs again for every canvas, and
@@ -6219,6 +7311,7 @@ class ThreeJsService {
         this.pickCamera = undefined;
         window.addEventListener('keydown', this.onKeyDown);
         // 6. Start the render loop
+        this.live = true;
         this.ngZone.runOutsideAngular(() => {
             this.animate();
         });
@@ -6255,33 +7348,25 @@ class ThreeJsService {
         }
         // Lets gltfpack/gltf-transform output using EXT_meshopt_compression load without extra setup.
         loader.setMeshoptDecoder(MeshoptDecoder);
-        this.modelLoading$.next(true);
+        const wanted = this.beginLoad();
         this.modelLoadProgress$.next(0);
         // Order matters: normals must exist before anisotropy, and the Phong conversion has to run
         // before side/flatShading are touched so those settings land on the materials we keep.
         const onLoaded = (gltf) => {
+            if (!wanted()) {
+                // Built for a request that has since been replaced or abandoned. It was never on screen;
+                // what it holds is freed here because nothing else ever will.
+                this.disposeModel(gltf.scene);
+                return;
+            }
             this.convertToPhongMaterials(gltf.scene);
             this.forceDoubleSidedMaterials(gltf.scene);
             this.ensureVertexNormals(gltf.scene);
             this.tuneTextureSampling(gltf.scene);
             this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation, up);
-            this.modelLoading$.next(false);
-        };
-        const onError = (error) => {
-            // Cancelling is a decision, not a failure: clear the overlay without an error in the console.
-            if (error?.name === 'AbortError') {
-                // Only a cancel of the load that is still current came from the user; anything else is this
-                // load having been superseded or discarded.
-                if (this.loadAbortController?.signal.aborted) {
-                    this.modelLoadCancelled$.next();
-                }
-            }
-            else {
-                console.error('Error loading GLTF model:', error);
-            }
-            this.modelLoading$.next(false);
-            this.modelLoadProgress$.next(null);
+            this.endLoad();
         };
+        const onError = (error) => this.loadFailed(wanted, error, 'GLTF model');
         // GLTFLoader decodes embedded images with createImageBitmap when the browser offers it, and on
         // large texture atlases that path returns visibly corrupt data - scattered white blocks across
         // the model. The exact same bytes decoded through an HTMLImageElement, which is what the .obj
@@ -6299,7 +7384,8 @@ class ThreeJsService {
             .then((buffer) => {
             // parse() cannot be interrupted, so a cancel that lands during the paint yield has to be
             // caught here - the last moment before the main thread is committed for several seconds.
-            if (this.loadAbortController?.signal.aborted) {
+            // The same goes for a load nobody is waiting for any more.
+            if (!wanted() || this.loadAbortController?.signal.aborted) {
                 throw new DOMException('Model load cancelled', 'AbortError');
             }
             const globalScope = globalThis;
@@ -6314,6 +7400,28 @@ class ThreeJsService {
         })
             .catch(onError);
     }
+    /** Ends a load that failed, unless another load has replaced it in the meantime. */
+    loadFailed(wanted, error, what) {
+        if (!wanted()) {
+            // Whatever replaced this load owns the loading indicator now; ending it from here would
+            // switch the indicator off while that one is still on its way.
+            return;
+        }
+        this.loadInProgress = false;
+        // Cancelling is a decision, not a failure: clear the overlay without an error in the console.
+        if (error?.name === 'AbortError') {
+            // Only a cancel of the load that is still current came from the user; anything else is this
+            // load having been superseded or discarded.
+            if (this.loadAbortController?.signal.aborted) {
+                this.modelLoadCancelled$.next();
+            }
+        }
+        else {
+            console.error(`Error loading ${what}:`, error);
+        }
+        this.modelLoading$.next(false);
+        this.modelLoadProgress$.next(null);
+    }
     /**
      * Stops the model download in progress, if any.
      *
@@ -6332,8 +7440,30 @@ class ThreeJsService {
      * scene is not something the person asked for, so it must not surface as "loading cancelled".
      */
     discardCurrentLoad() {
+        this.loadGeneration += 1;
         this.loadAbortController?.abort();
         this.loadAbortController = undefined;
+        if (this.loadInProgress) {
+            this.loadInProgress = false;
+            this.modelLoading$.next(false);
+            this.modelLoadProgress$.next(null);
+        }
+    }
+    /**
+     * Starts a load, replacing whichever was under way, and returns the question it has to keep
+     * asking: is it still the one that is wanted?
+     */
+    beginLoad() {
+        this.loadGeneration += 1;
+        const generation = this.loadGeneration;
+        this.loadInProgress = true;
+        this.modelLoading$.next(true);
+        return () => generation === this.loadGeneration;
+    }
+    /** Marks the wanted load as over, whichever way it ended. */
+    endLoad() {
+        this.loadInProgress = false;
+        this.modelLoading$.next(false);
     }
     /**
      * Resolves once the browser has painted at least one frame.
@@ -6364,6 +7494,11 @@ class ThreeJsService {
         this.loadAbortController = new AbortController();
         const { signal } = this.loadAbortController;
         const cached = await this.readModelFromCache(cacheKey);
+        if (signal.aborted) {
+            // Replaced or abandoned while the cache was being read. With nothing being downloaded, this
+            // is the only place a load served from the cache can find that out.
+            throw new DOMException('Model load cancelled', 'AbortError');
+        }
         if (cached) {
             this.modelLoadProgress$.next(1);
             return cached;
@@ -6704,12 +7839,25 @@ class ThreeJsService {
         const basePath = mtlUrl.substring(0, mtlUrl.lastIndexOf('/') + 1);
         mtlLoader.setPath(basePath);
         const mtlFileName = mtlUrl.substring(mtlUrl.lastIndexOf('/') + 1);
-        this.modelLoading$.next(true);
+        // These loaders cannot be interrupted, so a load that is no longer wanted runs to its end and
+        // is dropped there - see loadGeneration.
+        const wanted = this.beginLoad();
+        const finish = () => {
+            if (wanted()) {
+                this.endLoad();
+            }
+        };
         mtlLoader.load(mtlFileName, (materials) => {
+            if (!wanted()) {
+                return;
+            }
             materials.preload();
             if (this.objParserWorker) {
                 this.requestObjParseInWorker(objUrl)
                     .then((meshes) => {
+                    if (!wanted()) {
+                        return;
+                    }
                     const group = new THREE.Group();
                     meshes.forEach((meshData) => {
                         group.add(this.meshFromParsedData(meshData, materials));
@@ -6719,25 +7867,42 @@ class ThreeJsService {
                     .catch((error) => {
                     console.error('Error parsing OBJ model in worker:', error);
                 })
-                    .finally(() => this.modelLoading$.next(false));
+                    .finally(finish);
                 return;
             }
             const objLoader = new OBJLoader();
             objLoader.setMaterials(materials);
             objLoader.load(objUrl, (object) => {
+                if (!wanted()) {
+                    this.disposeModel(object);
+                    return;
+                }
                 this.placeLoadedObjectInScene(object, cameraPosition, rotation);
-                this.modelLoading$.next(false);
+                finish();
             }, undefined, (error) => {
                 console.error('Error loading OBJ model:', error);
-                this.modelLoading$.next(false);
+                finish();
             });
         }, undefined, (error) => {
             console.error('Error loading MTL file:', error);
-            this.modelLoading$.next(false);
+            finish();
         });
     }
     /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */
     placeLoadedObjectInScene(object, cameraPosition, rotation, up) {
+        // A scene shows one model. Whatever was there is taken out and freed first, or the two would be
+        // drawn through each other, every frame, for as long as the viewer stays open.
+        if (this.modelRoot) {
+            // Points being clicked for a calibration or a measurement were clicked on the model that is
+            // about to go; they say nothing about the one arriving.
+            if (this.aligning) {
+                this.cancelTagAlignment();
+            }
+            if (this.measuring) {
+                this.cancelMeasuring();
+            }
+        }
+        this.removeModel();
         const box = new THREE.Box3().setFromObject(object);
         const center = box.getCenter(new THREE.Vector3());
         const size = box.getSize(new THREE.Vector3());
@@ -6774,8 +7939,9 @@ class ThreeJsService {
         group.add(centered);
         group.scale.setScalar(scale);
         this.scene.add(group);
-        // Tags registered before the model finished loading were sized against the old scale.
-        this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));
+        this.scene.updateMatrixWorld(true);
+        // Markers registered before the model finished loading were sized against the old scale.
+        this.refreshScreenSizes();
         this.adjustClippingPlanes((size.length() / 2) * scale);
         if (cameraPosition) {
             this.camera.position.set(cameraPosition.x, cameraPosition.y, cameraPosition.z);
@@ -6791,16 +7957,25 @@ class ThreeJsService {
      * not clear enough to act on.
      *
      * Models arrive in two conventions: Y up (glTF, and what this viewer assumes) and Z up (most CAD
-     * and scanning exports). A Z-up model loads lying on its side. Two independent cues say which
-     * axis is the vertical one, and both have to agree before anything is turned:
+     * and scanning exports). A Z-up model loads lying on its side. Three independent cues say which
+     * axis is the vertical one:
      *
      *  - Surface area. Floors and ceilings all face along the vertical, while walls are shared out
      *    between the two horizontal axes, so the vertical usually collects the most area.
      *  - Extent. A building is normally wider than it is tall, so the vertical is its shortest side.
+     *  - Openness. A capture made from outside has ground and roofs but nothing underneath them, so
+     *    along the vertical nearly all of its surface faces one way; walls face both ways evenly.
+     *
+     * Each is wrong often enough on its own - a long corridor has more wall than floor, a tower is
+     * taller than it is wide - so a cue only counts when its answer is clear-cut, and the model is
+     * turned when the clear answers agree. It used to take area and extent agreeing with each other,
+     * which failed on exactly the models that need this most: in a whole building or a city block
+     * there is as much wall as floor, the area cue comes out a three-way tie, and a model 130 m wide
+     * and 34 m tall with 86% of its surface facing one way was left lying on its side.
      *
-     * Either alone is wrong often enough to matter - a long corridor has more wall than floor, a
-     * tower is taller than it is wide - and turning a model that was fine is worse than leaving one
-     * that was not. A model that already has Y as its vertical is never touched.
+     * Turning a model that was fine is worse than leaving one that was not: when the clear answers
+     * contradict each other, or there is none, nothing is turned. A model that already has Y as its
+     * vertical is never touched.
      */
     detectModelUp(object, size) {
         const axes = ['x', 'y', 'z'];
@@ -6815,6 +7990,7 @@ class ThreeJsService {
             }
         });
         if (triangleCount === 0) {
+            // Nothing with faces to weigh: the convention.
             return 'y';
         }
         // A sample is plenty to see where the area lies, and keeps this cheap on models with millions
@@ -6845,16 +8021,45 @@ class ThreeJsService {
             }
         });
         const total = { x: area.x[0] + area.x[1], y: area.y[0] + area.y[1], z: area.z[0] + area.z[1] };
-        const byArea = axes.reduce((best, axis) => (total[axis] > total[best] ? axis : best), 'y');
-        const byExtent = axes.reduce((best, axis) => (size[axis] < size[best] ? axis : best), 'y');
-        if (byArea === 'y' || byArea !== byExtent || total[byArea] < 1.25 * total.y) {
+        const extent = { x: size.x, y: size.y, z: size.z };
+        // How one-sided the surface is along each axis: 0 when it faces both ways evenly, 1 when it
+        // all faces the same way.
+        const lopsided = { x: 0, y: 0, z: 0 };
+        axes.forEach((axis) => {
+            lopsided[axis] = total[axis] > 0 ? Math.abs(area[axis][0] - area[axis][1]) / total[axis] : 0;
+        });
+        /** The axes ordered by a measure, largest first. */
+        const ranked = (measure) => [...axes].sort((first, second) => measure[second] - measure[first]);
+        const [mostArea, nextArea] = ranked(total);
+        const [, middleExtent, shortest] = ranked(extent);
+        const [mostOpen, nextOpen] = ranked(lopsided);
+        // What each cue says, when it says it clearly; null when it has no clear answer.
+        const areaSays = total[mostArea] >= 1.25 * total[nextArea] ? mostArea : null;
+        const extentSays = extent[middleExtent] >= 1.5 * extent[shortest] ? shortest : null;
+        const opennessSays = lopsided[mostOpen] >= 0.5
+            && lopsided[mostOpen] >= 2 * lopsided[nextOpen]
+            // Not on the strength of a few stray triangles: the surface along that axis has to matter.
+            && total[mostOpen] >= 0.25 * total[mostArea]
+            ? mostOpen
+            : null;
+        const clear = [areaSays, extentSays, opennessSays].filter((axis) => axis !== null);
+        let vertical = 'y';
+        if (clear.length > 0) {
+            // Clear answers that contradict each other are no answer.
+            vertical = clear.every((axis) => axis === clear[0]) ? clear[0] : 'y';
+        }
+        else if (mostArea === shortest && total[mostArea] >= 1.25 * total.y) {
+            // Nothing clear-cut, but area and extent lean the same way and away from Y.
+            vertical = mostArea;
+        }
+        if (vertical === 'y') {
             return 'y';
         }
         // Which way along that axis is up. Roofs and ground make an outdoor model face mostly upward,
         // which settles it; indoors floors and ceilings balance out, and the convention - positive is
         // up - is the better guess.
-        const [positive, negative] = area[byArea];
-        const up = `${negative > 0.65 * (positive + negative) ? '-' : ''}${byArea}`;
+        const [positive, negative] = area[vertical];
+        const up = `${negative > 0.65 * (positive + negative) ? '-' : ''}${vertical}`;
         console.info(`ThreeJsService: this model's vertical axis looks like ${up}, not y - standing it upright.`);
         return up;
     }
@@ -6904,6 +8109,7 @@ class ThreeJsService {
             this.camera.updateProjectionMatrix();
             this.renderer.setSize(width, height);
             this.updateMeasureLineResolution();
+            this.refreshScreenSizes();
         });
         this.canvasResizeObserver.observe(container);
     }
@@ -6914,6 +8120,34 @@ class ThreeJsService {
      * only has to supply the matching spot on the model. No new records are written; nothing is
      * applied until solveAlignmentFromPairs() succeeds.
      */
+    /**
+     * Shows every tag that came from elsewhere, whether or not it lands on the model, without arming
+     * anything: clicks still do what they always do.
+     *
+     * Calibrating shows them too, and ending a calibration - saved or abandoned - puts them back
+     * under the usual rule, so this only ever has to be switched on.
+     */
+    revealCalibrationTags(revealed = true) {
+        this.revealingCalibrationTags = revealed;
+        this.refreshTagVisibility();
+        // Another viewer showing the tags shows these as well now; see showsCalibrationTags.
+        this.announceTagsChanged();
+    }
+    /**
+     * Whether the tags a calibration works with are on show - while one is under way, or its panel
+     * open - including those that do not land on the model. For another viewer showing the tags,
+     * which otherwise leaves out the ones from elsewhere until the model is calibrated.
+     */
+    showsCalibrationTags() {
+        return this.aligning || this.revealingCalibrationTags;
+    }
+    /** Says a tag was clicked in a viewer drawing the model elsewhere, as a click on it here would. */
+    clickTag(elementId) {
+        const sprite = this.tagSprites.get(elementId);
+        if (sprite) {
+            this.tagClicked$.next({ elementId, poiType: sprite.userData.poiType ?? null });
+        }
+    }
     startTagAlignment() {
         // One pointer mode at a time, the same rule startMeasuring() applies the other way round.
         if (this.measuring) {
@@ -6921,27 +8155,28 @@ class ThreeJsService {
         }
         this.aligning = true;
         this.alignmentPairs = [];
-        this.alignmentSource = null;
+        this.clearAlignmentSource();
         // While calibrating, the tags from elsewhere are all shown - including the ones off the model,
         // which are exactly the ones a calibration is for.
         this.refreshTagVisibility();
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'crosshair';
         }
-        this.alignmentProgress$.next({ pairs: 0, awaiting: 'tag' });
+        this.alignmentChanged();
+        this.announceTagsChanged();
     }
     cancelTagAlignment() {
         const wasAligning = this.aligning;
         this.aligning = false;
+        this.revealingCalibrationTags = false;
         this.alignmentPairs = [];
-        this.alignmentSource = null;
-        this.pendingPreviewEvent = null;
-        this.removePlacementPreview();
+        this.clearAlignmentSource();
         this.refreshTagVisibility();
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'default';
         }
-        this.alignmentProgress$.next({ pairs: 0, awaiting: null });
+        this.alignmentChanged();
+        this.announceTagsChanged();
         if (wasAligning) {
             this.alignmentCancelled$.next();
         }
@@ -6989,11 +8224,10 @@ class ThreeJsService {
         // Out of calibrating mode first: applying the result re-decides which tags show, and from here
         // on that is the ones on the model again, not all of them.
         this.aligning = false;
+        this.revealingCalibrationTags = false;
         this.applyAlignmentKeepingOwnTags(alignment);
-        this.pendingPreviewEvent = null;
-        this.removePlacementPreview();
         this.renderer.domElement.style.cursor = 'default';
-        this.alignmentProgress$.next({ pairs: this.alignmentPairs.length, awaiting: null });
+        this.alignmentChanged();
         return alignment;
     }
     /**
@@ -7052,7 +8286,8 @@ class ThreeJsService {
      */
     selectAlignmentTag(elementId) {
         const sprite = this.tagSprites.get(elementId);
-        if (!this.aligning || this.alignmentSource || !sprite || !this.calibrationCandidates().includes(sprite)) {
+        if (!this.aligning || this.alignmentSource || !this.canMatchAnotherTag()
+            || !sprite || !this.calibrationCandidates().includes(sprite)) {
             return false;
         }
         this.setAlignmentSource(sprite);
@@ -7064,18 +8299,28 @@ class ThreeJsService {
         const stored = sprite.position;
         this.alignmentSource = { x: stored.x, y: stored.y, z: stored.z };
         this.alignmentSourceTagId = sprite.name;
-        this.alignmentProgress$.next({
-            pairs: this.alignmentPairs.length,
-            awaiting: 'point',
-            tagId: sprite.name,
-        });
+        this.alignmentChanged('tag');
+    }
+    clearAlignmentSource() {
+        this.alignmentSource = null;
+        this.alignmentSourceTagId = undefined;
+    }
+    /** Whether the calibration still has room for a pair and a tag to make it from. */
+    canMatchAnotherTag() {
+        return this.alignmentPairs.length < ThreeJsService.CALIBRATION_PAIRS
+            && this.calibrationCandidates().length > 0;
     }
     /** Handles a click while the alignment walkthrough is running. */
     handleAlignmentClick(event) {
         if (!this.alignmentSource) {
             // First half of a pair: which tag are we talking about?
+            if (!this.canMatchAnotherTag()) {
+                // Nothing left to match: what remains is to save, or to take a pair back.
+                return;
+            }
             const hit = this.raycaster.intersectObjects(this.calibrationCandidates(), false)[0];
             if (!hit) {
+                this.alignmentClickIgnored$.next('tag');
                 return;
             }
             this.setAlignmentSource(hit.object);
@@ -7084,18 +8329,220 @@ class ThreeJsService {
         // Second half: where that tag actually belongs on the model.
         const target = this.pickAlignmentTarget(event);
         if (!target) {
+            this.alignmentClickIgnored$.next('point');
             return;
         }
         this.alignmentPairs.push({ tagId: this.alignmentSourceTagId, source: this.alignmentSource, target });
-        this.alignmentSource = null;
-        // The ghost belongs to the click that just happened; the next half is a click on a tag.
+        this.clearAlignmentSource();
+        this.alignmentChanged('point');
+    }
+    /**
+     * Records where the tag being matched really is, from a spot another viewer picked on the model -
+     * the splat viewer - in the model's own coordinates: the frame pickAlignmentTarget measures a
+     * click in, as placeTagAtModelPoint takes it. False when no tag is waiting for its spot.
+     */
+    matchAlignmentTagAtModelPoint(point) {
+        if (!this.aligning || !this.alignmentSource) {
+            return false;
+        }
+        this.alignmentPairs.push({
+            tagId: this.alignmentSourceTagId,
+            source: this.alignmentSource,
+            target: { x: point.x, y: point.y, z: point.z },
+        });
+        this.clearAlignmentSource();
+        this.alignmentChanged('point');
+        return true;
+    }
+    /**
+     * Takes back the last thing done in the calibration under way: the choice of tag while its place
+     * on the model is being asked for, the last matched pair otherwise.
+     *
+     * One step at a time, so a click made by mistake costs that click and not the whole calibration.
+     * Returns false when there is nothing to take back.
+     */
+    undoAlignmentStep() {
+        if (!this.aligning) {
+            return false;
+        }
+        if (this.alignmentSource) {
+            this.clearAlignmentSource();
+        }
+        else if (this.alignmentPairs.length > 0) {
+            this.alignmentPairs.pop();
+        }
+        else {
+            return false;
+        }
+        this.alignmentChanged();
+        return true;
+    }
+    /**
+     * Removes one matched pair, whichever it is, putting its tag back on offer.
+     *
+     * For the point noticed to be wrong only after others were matched: taking steps back one by one
+     * to reach it would throw away the good ones made since.
+     */
+    removeAlignmentPair(index) {
+        if (!this.aligning || !Number.isInteger(index) || index < 0 || index >= this.alignmentPairs.length) {
+            return false;
+        }
+        this.alignmentPairs.splice(index, 1);
+        this.alignmentChanged();
+        return true;
+    }
+    /** The tags matched so far in the calibration under way, in the order they are numbered in. */
+    getAlignmentPairs() {
+        return this.alignmentPairs.map((pair) => {
+            const sprite = this.tagSprites.get(pair.tagId);
+            return {
+                tagId: pair.tagId,
+                label: sprite?.userData.label ?? null,
+                poiType: sprite?.userData.poiType ?? null,
+                target: { ...pair.target },
+            };
+        });
+    }
+    /**
+     * Brings the scene and the panel in line with the calibration's state, after anything changed it.
+     *
+     * `dropped` names the mark the change put down, if it put one down, so that it can be shown
+     * arriving: that movement is what tells someone their click was taken.
+     */
+    alignmentChanged(dropped) {
+        // The ghost previews the pin about to be dropped, number included, so it is never carried over
+        // from one state to the next; the next pointer move draws the right one.
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
+        if (this.aligning && this.renderer) {
+            this.renderer.domElement.style.cursor = 'crosshair';
+        }
+        this.redrawCalibrationMarks(dropped);
+        let awaiting = null;
+        if (this.aligning) {
+            if (this.alignmentSource) {
+                awaiting = 'point';
+            }
+            else if (this.canMatchAnotherTag()) {
+                // Otherwise done at three, or sooner when there are no more tags to match: fewer pairs
+                // still calibrate, only less completely.
+                awaiting = 'tag';
+            }
+        }
         this.alignmentProgress$.next({
             pairs: this.alignmentPairs.length,
-            // Done at three, or sooner when there are no more tags to match: fewer pairs still calibrate,
-            // only less completely.
-            awaiting: this.alignmentPairs.length >= 3 || this.calibrationCandidates().length === 0 ? null : 'tag',
+            awaiting,
+            tagId: awaiting === 'point' ? this.alignmentSourceTagId : undefined,
+            matched: this.getAlignmentPairs(),
+        });
+    }
+    /**
+     * Draws the calibration as it stands: what has been matched, and what is being matched.
+     *
+     * Redrawn whole on every change rather than patched. There are at most three pairs, and undoing
+     * or removing one renumbers the others.
+     */
+    redrawCalibrationMarks(dropped) {
+        this.clearCalibrationMarks();
+        if (!this.aligning) {
+            return;
+        }
+        const frame = this.tagGroup.parent ?? this.scene;
+        if (this.calibrationGroup.parent !== frame) {
+            frame.add(this.calibrationGroup);
+        }
+        this.tagGroup.updateMatrix();
+        // Where a tag is drawn at the moment, in the frame the marks are drawn in.
+        const drawnAt = (stored) => new THREE.Vector3(stored.x, stored.y, stored.z).applyMatrix4(this.tagGroup.matrix);
+        this.alignmentPairs.forEach((pair, index) => {
+            const target = new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z);
+            // From where the tag is to where it was said to belong: the correction, made visible.
+            const link = this.createMeasureLine(drawnAt(pair.source), target, ThreeJsService.CALIBRATION_DONE_COLOR, 2);
+            link.material.opacity = 0.75;
+            // The same green as the pin it leads to; see createCalibrationMark.
+            link.material.color.convertSRGBToLinear();
+            link.material.toneMapped = false;
+            // Behind the tags: it sets off from the middle of one, and should come out from under its
+            // icon rather than run across it.
+            link.renderOrder = 997;
+            this.calibrationGroup.add(link);
+            const pin = this.createCalibrationMark(this.createNumberedTexture(index + 1, ThreeJsService.CALIBRATION_DONE_COLOR), 1001);
+            pin.position.copy(target);
+            this.calibrationGroup.add(pin);
+            this.setScreenSize(pin, ThreeJsService.CALIBRATION_PIN_PX);
+            if (dropped === 'point' && index === this.alignmentPairs.length - 1) {
+                this.pulse(pin);
+            }
+            // Its tag is spoken for; it stays in view to show what the pin refers to, but stands back.
+            const matched = this.tagSprites.get(pair.tagId);
+            if (matched) {
+                matched.material.opacity = 0.4;
+            }
+        });
+        if (this.alignmentSource) {
+            const ring = this.createCalibrationMark(this.createRingTexture(ThreeJsService.MEASURE_COLOR), 998);
+            ring.position.copy(drawnAt(this.alignmentSource));
+            this.calibrationGroup.add(ring);
+            this.setScreenSize(ring, ThreeJsService.TAG_SCREEN_PX * 1.6);
+            if (dropped === 'tag') {
+                this.pulse(ring);
+            }
+        }
+    }
+    /** Removes everything drawn for a calibration, and gives the tags it dimmed their look back. */
+    clearCalibrationMarks() {
+        [...this.calibrationGroup.children].forEach((child) => {
+            this.calibrationGroup.remove(child);
+            child.geometry?.dispose?.();
+            child.material?.map?.dispose?.();
+            child.material?.dispose?.();
+        });
+        this.tagSprites.forEach((sprite) => {
+            sprite.material.opacity = 1;
+        });
+    }
+    /**
+     * A calibration mark: a fixed size on screen and showing through the model, as the tags do, and
+     * drawn in the colours it was painted in.
+     *
+     * The renderer's tone mapping and output conversion are there for the model's lighting. Put
+     * through them a mark comes out pale - the amber nearer to cream - and a mark that has to be
+     * picked out against a photograph of a building is the last thing that should be.
+     */
+    createCalibrationMark(map, renderOrder) {
+        // Says the canvas holds sRGB, which it does, so the output conversion gives it back unchanged.
+        if ('colorSpace' in map) {
+            map.colorSpace = 'srgb'; // THREE.SRGBColorSpace, r152+
+        }
+        else {
+            map.encoding = 3001; // THREE.sRGBEncoding
+        }
+        const mark = new THREE.Sprite(new THREE.SpriteMaterial({
+            map, depthTest: false, transparent: true, sizeAttenuation: false, toneMapped: false,
+        }));
+        mark.renderOrder = renderOrder;
+        return mark;
+    }
+    /** Shows a mark arriving: it starts oversized and settles. */
+    pulse(sprite) {
+        this.pulses.push({ sprite, startedAt: performance.now() });
+    }
+    stepPulses() {
+        if (this.pulses.length === 0) {
+            return;
+        }
+        const now = performance.now();
+        this.pulses = this.pulses.filter(({ sprite, startedAt }) => {
+            const size = sprite.userData.screenSize;
+            if (!sprite.parent || !size) {
+                // Redrawn or cleared in the meantime.
+                return false;
+            }
+            const progress = Math.min(1, (now - startedAt) / ThreeJsService.CONFIRM_PULSE_MS);
+            this.setScreenSize(sprite, size[0], size[1]);
+            // Eased out, so most of the settling happens while the eye is still on the click.
+            sprite.scale.multiplyScalar(1 + 0.9 * (1 - progress) ** 2);
+            return progress < 1;
         });
     }
     /**
@@ -7120,6 +8567,7 @@ class ThreeJsService {
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'crosshair';
         }
+        this.measuringChanged$.next(true);
         this.measurementProgress$.next({ points: 0, distances: [] });
     }
     /**
@@ -7140,8 +8588,10 @@ class ThreeJsService {
             this.renderer.domElement.style.cursor = 'default';
         }
         if (wasMeasuring) {
+            this.measuringChanged$.next(false);
             this.measurementProgress$.next(null);
         }
+        this.measurementCleared$.next();
     }
     /**
      * Ends the measurement and returns it, or null when there are not yet two points to measure
@@ -7150,11 +8600,12 @@ class ThreeJsService {
      * The drawing stays on the model so it is still visible while the person names the measurement;
      * cancelMeasuring() takes it away afterwards.
      */
-    finishMeasuring() {
+    finishMeasuring(screenshot) {
         if (!this.measuring || this.measurePoints.length < 2) {
             return null;
         }
         this.measuring = false;
+        this.measuringChanged$.next(false);
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
         this.updateMeasureRubberBand(null);
@@ -7162,10 +8613,32 @@ class ThreeJsService {
         this.lastMeasurement = {
             points: this.measurePoints.map((point) => ({ x: point.x, y: point.y, z: point.z })),
             distances: this.measureDistances(),
-            screenshot: this.captureMeasurementScreenshot(),
+            // From the viewer the model is drawn in, when it is not this scene: the splat viewer.
+            screenshot: screenshot ?? this.captureMeasurementScreenshot(),
         };
         return this.lastMeasurement;
     }
+    /**
+     * Adds a point to the measurement under way from a spot another viewer picked on the model - the
+     * splat viewer - in the model's own coordinates. Into the frame the measurement is kept in, the
+     * tags', through the calibration, as placeTagAtModelPoint does. False when not measuring.
+     */
+    addMeasurePointAtModelPoint(point) {
+        if (!this.measuring) {
+            return false;
+        }
+        this.tagGroup.updateMatrix();
+        this.addMeasurePoint(new THREE.Vector3(point.x, point.y, point.z).applyMatrix4(this.tagGroup.matrix.clone().invert()));
+        return true;
+    }
+    /** The measurement's points, under way or finished, in the model's own coordinates: for a viewer drawing it elsewhere. */
+    getMeasurePointsInModelFrame() {
+        this.tagGroup.updateMatrix();
+        return this.measurePoints.map((point) => {
+            const { x, y, z } = point.clone().applyMatrix4(this.tagGroup.matrix);
+            return { x, y, z };
+        });
+    }
     isMeasuring() {
         return this.measuring;
     }
@@ -7194,10 +8667,10 @@ class ThreeJsService {
             // anything sized in metres would cover the very thing being measured.
             sizeAttenuation: false,
         }));
-        marker.scale.set(0.022, 0.022, 1);
         marker.position.copy(point);
         marker.renderOrder = 1001;
         this.measureGroup.add(marker);
+        this.setScreenSize(marker, 12);
         if (previous) {
             this.measureGroup.add(this.createMeasureLine(previous, point));
             const distance = Math.round(previous.distanceTo(point) * 100) / 100;
@@ -7207,10 +8680,10 @@ class ThreeJsService {
                 transparent: true,
                 sizeAttenuation: false,
             }));
-            label.scale.set(0.15, 0.05, 1);
             label.position.copy(previous).add(point).multiplyScalar(0.5);
             label.renderOrder = 1002;
             this.measureGroup.add(label);
+            this.setScreenSize(label, 84, 28);
         }
         this.measurementProgress$.next({
             points: this.measurePoints.length,
@@ -7223,12 +8696,12 @@ class ThreeJsService {
      * WebGL's own lines are one pixel wide whatever is asked for, which all but disappears over a
      * photographic texture. This kind is drawn as screen-facing geometry, so the width holds.
      */
-    createMeasureLine(from, to) {
+    createMeasureLine(from, to, color = ThreeJsService.MEASURE_COLOR, width = 3) {
         const geometry = new LineGeometry();
         geometry.setPositions([from.x, from.y, from.z, to.x, to.y, to.z]);
         const material = new LineMaterial({
-            color: new THREE.Color(ThreeJsService.MEASURE_COLOR).getHex(),
-            linewidth: 3,
+            color: new THREE.Color(color).getHex(),
+            linewidth: width,
             depthTest: false,
             transparent: true,
         });
@@ -7244,7 +8717,7 @@ class ThreeJsService {
             return;
         }
         const size = this.renderer.getSize(new THREE.Vector2());
-        this.measureGroup.children.forEach((child) => {
+        [...this.measureGroup.children, ...this.calibrationGroup.children].forEach((child) => {
             if (child.material?.resolution) {
                 child.material.resolution.set(size.x, size.y);
             }
@@ -7330,6 +8803,12 @@ class ThreeJsService {
         });
         return canvas.toDataURL('image/jpeg', 0.85);
     }
+    /**
+     * True when tag placement is armed, false when it ends - placed or abandoned. For a viewer drawing
+     * the model instead of this scene, the splat viewer, which picks the spot itself; see
+     * placeTagAtModelPoint.
+     */
+    placementChanged$ = new Subject();
     /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
     startTagPlacement(poiType = null) {
         this.placingTag = true;
@@ -7338,9 +8817,40 @@ class ThreeJsService {
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'crosshair';
         }
+        this.placementChanged$.next(true);
+    }
+    /**
+     * Places the armed tag at a spot another viewer picked on the model - the splat viewer - given
+     * in the model's own coordinates, as a click on the model in this scene would. Into the frame tag
+     * coordinates are stored in, through the calibration, as pickPlacementOnModel does.
+     */
+    placeTagAtModelPoint(point, normal = null) {
+        if (!this.placingTag) {
+            return null;
+        }
+        this.tagGroup.updateMatrix();
+        const position = new THREE.Vector3(point.x, point.y, point.z).applyMatrix4(this.tagGroup.matrix.clone().invert());
+        // Turned only: the calibration's scale changes no direction.
+        const facing = normal
+            ? new THREE.Vector3(normal.x, normal.y, normal.z).applyQuaternion(this.tagGroup.quaternion.clone().invert()).normalize()
+            : new THREE.Vector3(0, 1, 0);
+        const placement = {
+            position: { x: position.x, y: position.y, z: position.z },
+            normal: { x: facing.x, y: facing.y, z: facing.z },
+            poiType: this.placementPoiType,
+        };
+        this.pendingTagPlacement = placement;
+        this.placingTag = false;
+        this.removePlacementPreview();
+        this.placementChanged$.next(false);
+        this.tagPlaced$.next(placement);
+        return placement;
     }
     /** Leaves placement mode without placing anything. */
     cancelTagPlacement() {
+        if (this.placingTag) {
+            this.placementChanged$.next(false);
+        }
         this.placingTag = false;
         this.pendingTagPlacement = null;
         this.pendingPreviewEvent = null;
@@ -7365,15 +8875,20 @@ class ThreeJsService {
         }
         this.renderer.domElement.style.cursor = 'crosshair';
         if (!this.placementPreview) {
-            this.placementPreview = new THREE.Sprite(new THREE.SpriteMaterial({
-                map: this.createTagTexture('#9E9E9E'),
-                depthTest: false,
-                transparent: true,
-                opacity: 0.6,
-            }));
+            // While calibrating, the ghost is the pin the click will leave, number and all: what is
+            // under the pointer is what stays there.
+            this.placementPreview = this.aligning
+                ? this.createCalibrationMark(this.createNumberedTexture(this.alignmentPairs.length + 1, ThreeJsService.CALIBRATION_DONE_COLOR), 999)
+                : new THREE.Sprite(new THREE.SpriteMaterial({
+                    map: this.createTagTexture('#9E9E9E'),
+                    depthTest: false,
+                    transparent: true,
+                    sizeAttenuation: false,
+                }));
             this.placementPreview.renderOrder = 999;
+            this.placementPreview.material.opacity = 0.6;
             this.tagGroup.add(this.placementPreview);
-            this.scaleTagForModel(this.placementPreview);
+            this.setScreenSize(this.placementPreview, this.aligning ? ThreeJsService.CALIBRATION_PIN_PX : ThreeJsService.TAG_SCREEN_PX);
         }
         this.placementPreview.position.copy(position);
         this.updateMeasureRubberBand(position);
@@ -7480,6 +8995,16 @@ class ThreeJsService {
     setVisibleTagTypes(types) {
         this.visibleTagTypes = types;
         this.tagSprites.forEach((sprite) => this.applyTagVisibility(sprite));
+        this.announceTagsChanged();
+    }
+    /** Says whether the visit on screen is the site's only one; see soleVisit. */
+    setSoleVisit(sole) {
+        this.soleVisit = sole;
+        this.tagSprites.forEach((sprite) => {
+            this.parentTag(sprite);
+            this.applyTagVisibility(sprite);
+        });
+        this.announceTagsChanged();
     }
     /** Says which capture is on screen, so the tags placed in it can be told from the rest. */
     setCurrentCapture(captureID) {
@@ -7488,6 +9013,7 @@ class ThreeJsService {
             this.parentTag(sprite);
             this.applyTagVisibility(sprite);
         });
+        this.announceTagsChanged();
     }
     /** Every tag registered in the scene, shown or not. */
     getTags() {
@@ -7563,8 +9089,8 @@ class ThreeJsService {
     }
     /** Whether the tag was placed in the visit on screen. */
     isOwnedByVisit(sprite) {
-        return !!sprite.userData.originCaptureID
-            && sprite.userData.originCaptureID === this.currentCaptureID;
+        const origin = sprite.userData.originCaptureID;
+        return origin ? origin === this.currentCaptureID : this.soleVisit;
     }
     /**
      * A tag shows when its type is not filtered out and it belongs on this model.
@@ -7593,8 +9119,9 @@ class ThreeJsService {
         if (sprite.userData.frame === 'model') {
             return false;
         }
-        // Calibrating is matching tags to where they belong, so they all have to be on offer.
-        if (this.aligning) {
+        // Calibrating is matching tags to where they belong, so they all have to be on offer - from
+        // the moment the panel opens, not only once the first click is being waited for.
+        if (this.aligning || this.revealingCalibrationTags) {
             return true;
         }
         return this.isOnModel(sprite);
@@ -7732,6 +9259,9 @@ class ThreeJsService {
      */
     goToTag(elementId) {
         const sprite = this.tagSprites.get(elementId);
+        if (sprite) {
+            this.tagFocused$.next(elementId);
+        }
         if (!sprite || !this.camera) {
             return;
         }
@@ -7853,10 +9383,11 @@ class ThreeJsService {
         this.tagGroup.rotation.set(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);
         this.tagGroup.scale.setScalar(scale ?? 1);
         this.tagGroup.updateMatrix();
-        // Tag size is derived from the world scale it inherits, which this call just changed - and so
-        // is which tags land on the model.
-        this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));
+        // Marker sizes are worked back from the scale they inherit, which this call just changed - and
+        // so is which tags land on the model.
+        this.refreshScreenSizes();
         this.refreshTagVisibility();
+        this.announceTagsChanged();
     }
     /**
      * Adds a tag, or moves/restyles the one already registered for this element.
@@ -7873,22 +9404,29 @@ class ThreeJsService {
             existing.userData.label = tag.label ?? existing.userData.label;
             existing.userData.originCaptureID = tag.originCaptureID ?? existing.userData.originCaptureID;
             existing.userData.frame = tag.frame ?? existing.userData.frame;
+            existing.userData.iconUrl = tag.iconUrl ?? existing.userData.iconUrl;
+            existing.userData.normal = tag.normal ?? existing.userData.normal;
             this.parentTag(existing);
             this.applyTagVisibility(existing);
+            this.announceTagsChanged();
             return;
         }
         const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
             map: this.createTagTexture(tag.color),
             // Tags read as UI rather than geometry, so they stay visible through the model instead of
-            // being occluded by whatever wall happens to be between them and the camera.
+            // being occluded by whatever wall happens to be between them and the camera - and, for
+            // the same reason, keep one size on screen rather than a size in the model.
             depthTest: false,
             transparent: true,
+            sizeAttenuation: false,
         }));
         sprite.name = tag.id;
         sprite.userData.poiType = tag.poiType ?? null;
         sprite.userData.label = tag.label ?? null;
         sprite.userData.originCaptureID = tag.originCaptureID ?? null;
         sprite.userData.frame = tag.frame ?? null;
+        sprite.userData.iconUrl = tag.iconUrl ?? null;
+        sprite.userData.normal = tag.normal ?? null;
         sprite.position.set(tag.position.x, tag.position.y, tag.position.z);
         sprite.renderOrder = 999;
         this.parentTag(sprite);
@@ -7898,6 +9436,52 @@ class ThreeJsService {
         if (tag.iconUrl) {
             this.applyTagIcon(sprite, tag.iconUrl);
         }
+        this.announceTagsChanged();
+    }
+    /**
+     * The tags another viewer should show, and the calibration they are drawn under.
+     *
+     * The same ones this scene would offer, short of the test against the model's surface, which needs
+     * the model here: the type filter applies, and a tag placed in another model before it was
+     * calibrated is left out, its coordinates meaning nothing in this one.
+     */
+    getTagSnapshot() {
+        const tags = [];
+        this.tagSprites.forEach((sprite) => {
+            const owned = this.isOwnedByVisit(sprite);
+            const typeAllowed = this.visibleTagTypes === null || this.visibleTagTypes.includes(sprite.userData.poiType);
+            if (!typeAllowed || (sprite.userData.frame === 'model' && !owned)) {
+                return;
+            }
+            tags.push({
+                id: sprite.name,
+                position: { x: sprite.position.x, y: sprite.position.y, z: sprite.position.z },
+                label: sprite.userData.label ?? null,
+                poiType: sprite.userData.poiType ?? null,
+                iconUrl: sprite.userData.iconUrl ?? null,
+                inModelFrame: sprite.userData.frame === 'model' && owned,
+                normal: sprite.userData.normal ?? null,
+            });
+        });
+        const group = this.tagGroup;
+        return {
+            tags,
+            alignment: {
+                translation: { x: group.position.x, y: group.position.y, z: group.position.z },
+                rotation: { x: group.rotation.x, y: group.rotation.y, z: group.rotation.z },
+                scale: group.scale.x,
+            },
+        };
+    }
+    announceTagsChanged() {
+        if (this.tagsChangeQueued) {
+            return;
+        }
+        this.tagsChangeQueued = true;
+        queueMicrotask(() => {
+            this.tagsChangeQueued = false;
+            this.tagsChanged$.next();
+        });
     }
     /** Removes the tag registered for an element, if there is one. */
     removeTag(elementId) {
@@ -7909,6 +9493,7 @@ class ThreeJsService {
         sprite.material.map?.dispose();
         sprite.material.dispose();
         this.tagSprites.delete(elementId);
+        this.announceTagsChanged();
     }
     /** Removes every tag from the scene. */
     clearTags() {
@@ -7938,18 +9523,78 @@ class ThreeJsService {
         context.stroke();
         return new THREE.CanvasTexture(canvas);
     }
+    /** The default marker with a number on it: the nth point of a calibration. */
+    createNumberedTexture(number, color) {
+        const texture = this.createTagTexture(color);
+        const canvas = texture.image;
+        const context = canvas.getContext('2d');
+        context.fillStyle = '#FFFFFF';
+        context.font = 'bold 76px sans-serif';
+        context.textAlign = 'center';
+        context.textBaseline = 'middle';
+        context.fillText(String(number), canvas.width / 2, canvas.height / 2 + 5);
+        return texture;
+    }
+    /** A ring with nothing in the middle, to go round a tag and leave it showing. */
+    createRingTexture(color) {
+        const size = 128;
+        const canvas = document.createElement('canvas');
+        canvas.width = size;
+        canvas.height = size;
+        const context = canvas.getContext('2d');
+        // White under the colour, a little wider, for the same reason the tags have a white edge.
+        context.beginPath();
+        context.arc(size / 2, size / 2, size / 2 - 10, 0, Math.PI * 2);
+        context.lineWidth = 16;
+        context.strokeStyle = '#FFFFFF';
+        context.stroke();
+        context.lineWidth = 10;
+        context.strokeStyle = color;
+        context.stroke();
+        return new THREE.CanvasTexture(canvas);
+    }
     /**
-     * Sizes a tag relative to the model.
+     * Gives a tag its size: the same number of pixels on screen whatever the model.
      *
-     * A sprite inherits the model's scale and the alignment's, so a fixed size would come out tiny on
-     * a large model and huge on a small one. Dividing by the group's world scale keeps tags the same
-     * size on screen whatever the model's units are.
+     * It used to be a fixed fraction of the model instead. That reads fine on a room, but on a model
+     * the size of a city block it is a tag several metres across, which fills the view as soon as
+     * the camera moves in to look at anything.
      */
     scaleTagForModel(sprite) {
-        // Its own parent's scale: tags in the model's coordinates do not inherit the calibration's.
-        const worldScale = (sprite.parent ?? this.tagGroup).getWorldScale(new THREE.Vector3()).x || 1;
-        const size = 0.4 / worldScale;
-        sprite.scale.set(size, size, 1);
+        this.setScreenSize(sprite, ThreeJsService.TAG_SCREEN_PX);
+    }
+    /**
+     * Fixes a sprite's size on screen, in CSS pixels.
+     *
+     * The sprite must be drawn without size attenuation, which makes its size a proportion of the
+     * viewport instead of something that shrinks with distance. Its scale is then worked back from
+     * the pixels wanted, the viewport's height and the scale it inherits from its parents - the
+     * model's normalisation and, for tags, the calibration - so none of those show in the result.
+     * The size asked for is kept on the sprite, so it can be worked out again when any of them changes.
+     */
+    setScreenSize(sprite, widthPx, heightPx = widthPx) {
+        sprite.userData.screenSize = [widthPx, heightPx];
+        const inherited = (sprite.parent ?? this.tagGroup).getWorldScale(new THREE.Vector3()).x || 1;
+        const perPixel = this.worldUnitsPerPixel() / inherited;
+        sprite.scale.set(widthPx * perPixel, heightPx * perPixel, 1);
+    }
+    /** What one screen pixel is worth in the scale of a sprite drawn without size attenuation. */
+    worldUnitsPerPixel() {
+        const height = this.renderer?.getSize?.(new THREE.Vector2()).y || 800;
+        const fieldOfView = THREE.MathUtils.degToRad(this.camera?.fov ?? 75);
+        return (2 * Math.tan(fieldOfView / 2)) / height;
+    }
+    /** Re-applies every marker's on-screen size: the viewport, the model or the calibration changed. */
+    refreshScreenSizes() {
+        const resize = (object) => {
+            if (object?.userData?.screenSize) {
+                this.setScreenSize(object, object.userData.screenSize[0], object.userData.screenSize[1]);
+            }
+        };
+        this.tagSprites.forEach(resize);
+        this.measureGroup.children.forEach(resize);
+        this.calibrationGroup.children.forEach(resize);
+        resize(this.placementPreview);
     }
     /**
      * Adds secondary interactive objects (e.g., POIs, sensors) to the scene.
@@ -8063,6 +9708,7 @@ class ThreeJsService {
                     this.placingTag = false;
                     this.removePlacementPreview();
                     this.renderer.domElement.style.cursor = 'default';
+                    this.placementChanged$.next(false);
                     this.tagPlaced$.next(placement);
                 }
                 return;
@@ -8090,12 +9736,19 @@ class ThreeJsService {
         }
     }
     /**
-     * Escape cancels whatever the pointer is currently committed to.
+     * Escape cancels whatever the pointer is currently committed to. While calibrating, the undo keys
+     * take back one step of it instead of all of it.
      *
      * Emits through the same subjects the explicit Cancel buttons use, so the UI driving them follows
      * along instead of being left showing a mode that is no longer armed.
      */
     onKeyDown = (event) => {
+        if (this.aligning && this.isUndoKey(event)) {
+            if (this.undoAlignmentStep()) {
+                event.preventDefault();
+            }
+            return;
+        }
         if (event.key !== 'Escape') {
             return;
         }
@@ -8112,9 +9765,22 @@ class ThreeJsService {
             this.cancelTagAlignment();
         }
     };
+    /**
+     * Ctrl+Z (Cmd+Z on a Mac) or Backspace, unless typed into a field - where they mean something
+     * else, to whatever the field is.
+     */
+    isUndoKey(event) {
+        const target = event.target;
+        if (target?.isContentEditable || ['INPUT', 'TEXTAREA'].includes(target?.tagName ?? '')) {
+            return false;
+        }
+        return event.key === 'Backspace'
+            || ((event.ctrlKey || event.metaKey) && !event.shiftKey && event.key.toLowerCase() === 'z');
+    }
     animate = () => {
         this.animationFrameId = requestAnimationFrame(this.animate);
         this.stepCameraTween();
+        this.stepPulses();
         this.controls.update();
         // One pick per frame, against the pointer's latest position - see onMouseMove.
         if (this.pendingPreviewEvent) {
@@ -8124,11 +9790,84 @@ class ThreeJsService {
         }
         this.renderer.render(this.scene, this.camera);
     };
-    destroy() {
+    /**
+     * Stops drawing the scene, or starts again. For while another viewer covers it - the splat viewer
+     * - where it would otherwise go on drawing, unseen, every frame, on the graphics card the other
+     * viewer needs. The scene keeps its tags and calibration all the same.
+     */
+    setRenderingPaused(paused) {
+        if (paused) {
+            this.stopRendering();
+        }
+        else if (this.live && !this.animationFrameId) {
+            this.ngZone.runOutsideAngular(() => this.animate());
+        }
+    }
+    /** Stops the render loop, if one is running. */
+    stopRendering() {
         if (this.animationFrameId) {
             cancelAnimationFrame(this.animationFrameId);
+            this.animationFrameId = 0;
         }
+    }
+    /**
+     * Takes the model out of the scene and frees what it holds on the graphics card.
+     *
+     * The tags are kept. They hang from the model's group so as to share its frame, and are moved out
+     * of it first: they belong to the visit, not to the file that was drawn under them.
+     */
+    removeModel() {
+        const group = this.modelGroup;
+        const model = this.modelRoot;
+        this.modelGroup = undefined;
+        this.modelRoot = undefined;
+        this.surfaceCells = null;
+        this.modelWorldRadius = 0;
+        [this.tagGroup, this.modelTagGroup, this.calibrationGroup].forEach((kept) => kept.parent?.remove(kept));
+        group?.parent?.remove(group);
+        if (model) {
+            this.disposeModel(model);
+        }
+    }
+    /**
+     * Frees a model's geometry, materials and textures.
+     *
+     * Dropping the last reference to a model does not do this. What it uploaded stays on the graphics
+     * card until the page is closed - hundreds of megabytes for a captured building - and on a
+     * machine whose graphics memory is shared with the rest of the system, everything slows down
+     * long before anything fails.
+     */
+    disposeModel(model) {
+        const freed = new Set();
+        const free = (resource) => {
+            if (resource && typeof resource.dispose === 'function' && !freed.has(resource)) {
+                freed.add(resource);
+                resource.dispose();
+            }
+        };
+        model.traverse((child) => {
+            free(child.geometry);
+            const materials = Array.isArray(child.material) ? child.material : [child.material];
+            materials.forEach((material) => {
+                if (!material) {
+                    return;
+                }
+                // Whichever slots this kind of material has: map, normalMap, emissiveMap...
+                Object.values(material).forEach((value) => {
+                    if (value?.isTexture) {
+                        free(value);
+                    }
+                });
+                free(material);
+            });
+        });
+    }
+    destroy() {
+        this.live = false;
+        this.stopRendering();
         window.removeEventListener('keydown', this.onKeyDown);
+        this.canvasListeners.forEach((remove) => remove());
+        this.canvasListeners = [];
         if (this.canvasResizeObserver) {
             this.canvasResizeObserver.disconnect();
             this.canvasResizeObserver = undefined;
@@ -8137,6 +9876,13 @@ class ThreeJsService {
         this.clearTags();
         this.measuring = false;
         this.clearMeasurement();
+        this.clearCalibrationMarks();
+        this.pulses = [];
+        // While the renderer is still there to hand the memory back through.
+        this.removeModel();
+        // They were in the scene that is going. Kept, the next scene would go on testing every pointer
+        // move against objects nobody can see, and would skip loading them again as "already there".
+        this.clickableObjects = [];
         if (this.renderer) {
             this.renderer.dispose();
         }
@@ -8622,6 +10368,39 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
 /* eslint-disable camelcase */
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable class-methods-use-this */
+/**
+ * What a Gaussian splat file is named with, when it is a .ply: the content is what tells it from
+ * another .ply, and the key is all a visit stores (see isGaussianSplatPly).
+ */
+const GAUSSIAN_SPLAT_PLY_SUFFIX = '.splat.ply';
+/**
+ * Whether a 3D model file holds Gaussian splats, which the Three.js viewer cannot draw: .spz,
+ * .splat, .ksplat, SuperSplat's .sog, a .ply named with GAUSSIAN_SPLAT_PLY_SUFFIX, or the
+ * lod-meta.json of a Streamed SOG - SuperSplat's levels of detail, in pieces beside it.
+ */
+function isGaussianSplatFile(name) {
+    return /\.(spz|splat|ksplat|sog|splat\.ply)($|\?)/i.test(name ?? '') || isStreamedSplatFile(name);
+}
+/**
+ * Whether a .ply holds Gaussian splats: what splat tools export carries, for each splat, its colour
+ * as spherical harmonics (f_dc_0...) and its size (scale_0...). Only the header is read.
+ */
+async function isGaussianSplatPly(file) {
+    const start = await file.slice(0, 64 * 1024).text();
+    const end = start.indexOf('end_header');
+    if (!start.startsWith('ply') || end < 0) {
+        return false;
+    }
+    const properties = start.slice(0, end).split(/\r?\n/)
+        .map((line) => line.trim().split(/\s+/))
+        .filter((words) => words[0] === 'property')
+        .map((words) => words[words.length - 1]);
+    return properties.includes('f_dc_0') && properties.includes('scale_0');
+}
+/** Whether a 3D model file is the lod-meta.json of a Streamed SOG; see isGaussianSplatFile. */
+function isStreamedSplatFile(name) {
+    return /(^|\/)lod-meta\.json($|\?)/i.test(name ?? '');
+}
 class ViewerService {
     sdkKey;
     config;
@@ -8898,15 +10677,35 @@ class ViewerService {
         if (![position?.x, position?.y, position?.z].every((value) => typeof value === 'number')) {
             return;
         }
+        // A tag is its position; the icon is how it is dressed. One that cannot be fetched - a
+        // signature that expired, a file gone from the bucket - must not cost the tag itself.
+        let iconUrl;
+        try {
+            iconUrl = await this.resolveTagIconUrl(poi);
+        }
+        catch (error) {
+            console.warn(`ViewerService: no icon for the tag of element ${object.id}, using the default one.`, error);
+            iconUrl = this.defaultTagIconUrl(poi.type);
+        }
         const origin = getThreeJsPoiOrigin(poi);
+        // Matterport's stem, kept with the POI by both viewers that place tags.
+        let normal = null;
+        try {
+            const stored = poi.metadata ? JSON.parse(poi.metadata)?.normal : null;
+            normal = [stored?.x, stored?.y, stored?.z].every((value) => typeof value === 'number') ? stored : null;
+        }
+        catch {
+            normal = null;
+        }
         this.threeJsService.upsertTag({
             id: object.id,
             position,
             poiType: poi.type,
             label: object.name ?? object.title ?? null,
-            iconUrl: await this.resolveTagIconUrl(poi),
+            iconUrl,
             originCaptureID: origin?.captureID ?? null,
             frame: origin?.frame ?? null,
+            normal,
         });
     }
     /**
@@ -9024,6 +10823,40 @@ class ViewerService {
             this.threeJsService.goToTag(elementId);
         }
     }
+    /** The tag the Three.js camera is sent to, for the splat viewer to point out; see goToThreeJsTag. */
+    get threeJsTagFocused$() {
+        return this.threeJsService.tagFocused$;
+    }
+    /** A tag clicked in the splat viewer, said as threeJsTagClicked$ says one clicked in the scene. */
+    clickThreeJsTag(elementId) {
+        if (this.checkMode('threejs')) {
+            this.threeJsService.clickTag(elementId);
+        }
+    }
+    /** Whether the visit's 3D model has a calibration, from its capture's metadata. */
+    isThreeJsCalibrated() {
+        return this.threeJsCalibrated;
+    }
+    /** Whether the tags a calibration works with are on show; see ThreeJsService.showsCalibrationTags. */
+    isThreeJsShowingCalibrationTags() {
+        return this.checkMode('threejs') && this.threeJsService.showsCalibrationTags();
+    }
+    /** Whether a calibration is under way in the Three.js scene. */
+    isThreeJsAligningTags() {
+        return this.checkMode('threejs') && this.threeJsService.isAligningTags();
+    }
+    /** Whether a measurement is taking clicks in the Three.js scene. */
+    isThreeJsMeasuring() {
+        return this.checkMode('threejs') && this.threeJsService.isMeasuring();
+    }
+    /** True when a measurement starts taking clicks, false when it stops; see ThreeJsService.measuringChanged$. */
+    get threeJsMeasuringChanged$() {
+        return this.threeJsService.measuringChanged$;
+    }
+    /** Says a click in the splat viewer was of no use to the calibration, as one in the scene would. */
+    ignoreThreeJsAlignmentClick(expected) {
+        this.threeJsService.alignmentClickIgnored$.next(expected);
+    }
     /** Shows only tags of the given POI types; null clears the filter. */
     setVisibleThreeJsTagTypes(types) {
         if (this.checkMode('threejs')) {
@@ -9046,6 +10879,24 @@ class ViewerService {
             this.threeJsService.cancelTagAlignment();
         }
     }
+    /**
+     * Says whether the 3D model on screen is the site's only visit. Then there is nowhere else for a
+     * tag to have come from, and the tags that do not record where they were placed are its own.
+     */
+    setThreeJsSoleVisit(sole) {
+        if (this.checkMode('threejs')) {
+            this.threeJsService.setSoleVisit(sole);
+        }
+    }
+    /**
+     * Shows the tags a calibration would work with, including those hidden for not landing on the
+     * model, before anything is armed. Cancelling or saving the calibration hides them again.
+     */
+    revealThreeJsCalibrationTags() {
+        if (this.checkMode('threejs')) {
+            this.threeJsService.revealCalibrationTags(true);
+        }
+    }
     get threeJsAlignmentProgress$() {
         return this.threeJsService.alignmentProgress$;
     }
@@ -9220,17 +11071,35 @@ class ViewerService {
     get threeJsMeasurementProgress$() {
         return this.threeJsService.measurementProgress$;
     }
-    /** Ends the Three.js measurement in progress, or returns null when it has fewer than two points. */
-    finishThreeJsMeasurement() {
+    /**
+     * Ends the Three.js measurement in progress, or returns null when it has fewer than two points.
+     * `screenshot` is the picture of it, when the model is drawn by another viewer than the scene.
+     */
+    finishThreeJsMeasurement(screenshot) {
         if (!this.checkMode('threejs')) {
             return null;
         }
-        const measurement = this.threeJsService.finishMeasuring();
+        const measurement = this.threeJsService.finishMeasuring(screenshot);
         if (measurement) {
             this.toolboxStates.mesure.stat = false;
         }
         return measurement;
     }
+    /** A measurement was taken off the model, finished or not; see ThreeJsService.measurementCleared$. */
+    get threeJsMeasurementCleared$() {
+        return this.threeJsService.measurementCleared$;
+    }
+    /**
+     * Adds a point to the measurement under way, picked on the model in another viewer - the splat
+     * viewer - in the model's own coordinates. False when no measurement is under way.
+     */
+    addThreeJsMeasurePointAtModelPoint(point) {
+        return this.checkMode('threejs') && this.threeJsService.addMeasurePointAtModelPoint(point);
+    }
+    /** The points of the measurement on the model, in the model's own coordinates, for another viewer to draw. */
+    getThreeJsMeasurePointsInModelFrame() {
+        return this.checkMode('threejs') ? this.threeJsService.getMeasurePointsInModelFrame() : [];
+    }
     /** The measurement last finished in the Three.js viewer, for the form that saves it. */
     getThreeJsLastMeasurement() {
         return this.checkMode('threejs') ? this.threeJsService.getLastMeasurement() : null;
@@ -9292,6 +11161,24 @@ class ViewerService {
     selectThreeJsAlignmentTag(elementId) {
         return this.checkMode('threejs') && this.threeJsService.selectAlignmentTag(elementId);
     }
+    /**
+     * Gives the tag being matched in the calibration under way its real place, picked on the model in
+     * another viewer - the splat viewer - in the model's own coordinates. False when no tag was waiting.
+     */
+    matchThreeJsAlignmentTagAtModelPoint(point) {
+        return this.checkMode('threejs') && this.threeJsService.matchAlignmentTagAtModelPoint(point);
+    }
+    /**
+     * Takes back the last step of the calibration under way: the tag just chosen, or else the last
+     * pair matched. False when there was nothing to take back.
+     */
+    undoThreeJsAlignmentStep() {
+        return this.checkMode('threejs') && this.threeJsService.undoAlignmentStep();
+    }
+    /** Removes one matched pair of the calibration under way, by its place in the list. */
+    removeThreeJsAlignmentPair(index) {
+        return this.checkMode('threejs') && this.threeJsService.removeAlignmentPair(index);
+    }
     /** How far the visible tags sit from the 3D model, in model radii. Null without both. */
     getThreeJsTagDistanceFromModel() {
         return this.checkMode('threejs') ? this.threeJsService.getTagDistanceFromModel() : null;
@@ -9366,6 +11253,11 @@ class ViewerService {
             position: placement.position,
             poiType: updatedPoi?.type ?? poi.type,
             iconUrl: updatedPoi?.tagIcon ? await getSignedFile(updatedPoi.tagIcon) : null,
+            normal: placement.normal,
+            // As it is stored (see buildThreeJsPoiMetadata): placed in this model, and in its own
+            // coordinates while it is not calibrated - so that it shows as the model's own straight away.
+            ...(this.currentCaptureID ? { originCaptureID: this.currentCaptureID } : {}),
+            ...(this.currentCaptureID && !this.threeJsCalibrated ? { frame: 'model' } : {}),
         });
         this.threeJsService.cancelTagPlacement();
         return updatedPoi;
@@ -9380,7 +11272,7 @@ class ViewerService {
      *
      * Returns null when there is no pending placement, which is the normal case in Matterport mode.
      */
-    async createPoiForThreeJsPlacement(element, poiType) {
+    async createPoiForThreeJsPlacement(element, poiType, extra = {}) {
         if (!this.checkMode('threejs')) {
             return null;
         }
@@ -9392,6 +11284,8 @@ class ViewerService {
         // sweep - the floor plan most visibly, which only draws tags whose sweep belongs to it.
         const matterportSweepID = await this.findNearestSweepForThreeJs(placement.position);
         const poi = await this.poiService.createPOIForSpaceID({
+            // What a form asked for besides the place - the museum's, say - under what the placement says.
+            ...extra,
             coordinate: JSON.stringify(placement.position),
             type: poiType,
             elementID: element.id,
@@ -9413,6 +11307,35 @@ class ViewerService {
     get threeJsAlignmentCancelled$() {
         return this.threeJsService.alignmentCancelled$;
     }
+    /** Emits when the Three.js tags change; see getThreeJsTagSnapshot. */
+    get threeJsTagsChanged$() {
+        return this.threeJsService.tagsChanged$;
+    }
+    /** The tags, and their calibration, as a viewer drawing the scene elsewhere needs them. */
+    getThreeJsTagSnapshot() {
+        return this.threeJsService.getTagSnapshot();
+    }
+    /** Stops drawing the Three.js scene while another viewer covers it, or starts again. */
+    setThreeJsRenderingPaused(paused) {
+        this.threeJsService.setRenderingPaused(paused);
+    }
+    /** Emits when a click during calibration landed on nothing it could use: a tag, or the model. */
+    get threeJsAlignmentClickIgnored$() {
+        return this.threeJsService.alignmentClickIgnored$;
+    }
+    /** Emits when Three.js tag placement is armed (true) and when it ends (false). */
+    get threeJsPlacementChanged$() {
+        return this.threeJsService.placementChanged$;
+    }
+    /**
+     * Completes an armed Three.js tag placement at a spot the splat viewer picked, in the model's own
+     * coordinates: the creation form then opens as for a click in the Three.js scene.
+     */
+    placeThreeJsTagAtModelPoint(point, normal = null) {
+        if (this.checkMode('threejs')) {
+            this.threeJsService.placeTagAtModelPoint(point, normal);
+        }
+    }
     /** Leaves Three.js tag placement mode without placing anything. */
     cancelThreeJsTagPlacement() {
         if (this.checkMode('threejs')) {
@@ -9563,7 +11486,12 @@ class ViewerService {
         }
     }
     async initMatterportSdk(spaceID, model3D, tagService, module = SpModule.IMMO) {
-        this.isLoaded = false;
+        // A Three.js visit is announced as loaded by initThreeJs, and when one visit is swapped for
+        // another that has already happened by the time this runs. Clearing the flag here left the
+        // rest of the page believing no viewer was up - "show in 3D" greyed out on every panel.
+        if (!this.checkMode('threejs')) {
+            this.isLoaded = false;
+        }
         this.matterportService.currentSpaceID = spaceID;
         if (this.matterportService.sdk) {
             await this.clearAll();
@@ -16626,6 +18554,358 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Input
             }] } });
 
+/**
+ * Gaussian splats, drawn by SuperSplat's viewer (PlayCanvas) in an iframe, as Matterport's showcase
+ * is: the page built from projects/splat-viewer, which each app serves from assets/viewers/splat.
+ *
+ * The visit's Three.js scene stays underneath, unseen, holding the tags, their calibration and the
+ * measurement, as it does for a model it draws itself; this hands the viewer what the scene holds,
+ * and turns what is clicked in it into what a click in the scene does - through ViewerService, so
+ * that whatever drives the scene (the add buttons, the calibration panel, the measuring tool, the
+ * tag lists) drives this as well. Tags clicked come out of ViewerService.threeJsTagClicked$, as
+ * clicks in the scene do.
+ *
+ * What it says of loading is for the app's own loading overlay; see the outputs.
+ */
+class SplatViewerComponent {
+    viewerService;
+    host;
+    sanitizer;
+    translate;
+    /** The model: the S3 key - or assets/ path - of a splat file, or of a Streamed SOG's lod-meta.json. */
+    modelKey = null;
+    /** Which of the model's axes is up, from its capture's placement; null for the viewer's own idea. */
+    up = null;
+    /** How far loading has got, from 0 to 1, or null when the size is not known. 0 when it starts. */
+    loadProgress = new EventEmitter();
+    loaded = new EventEmitter();
+    loadFailed = new EventEmitter();
+    /** Said whenever the mode changes, the viewer's own buttons included. */
+    modeChange = new EventEmitter();
+    frame;
+    /**
+     * The viewer's page, made once, in ngOnInit: a new object, even for the same address, would make
+     * Angular set the iframe's src again, which loads the viewer afresh with nothing in it.
+     */
+    page;
+    /** Whether the page has said it is ready; it says so again each time it starts over. */
+    ready = false;
+    /** The model handed to the page, so the same one is not downloaded twice. */
+    loadedKey = null;
+    /** Set by cancelLoad: the page, starting over empty, waits to be asked again (reload). */
+    cancelled = false;
+    /** Whether the page was last asked to take a click for a calibration. */
+    pickingForCalibration = false;
+    /** The calibration under way, as ViewerService last said. */
+    alignment = null;
+    /** Each segment's length of the measurement on the model, as ViewerService last said. */
+    measureDistances = [];
+    /** The last lod-meta.json handed to the page, as a link of this page's own. */
+    streamedMeta = null;
+    /** Pictures asked of the page, by the number they were asked with, until it answers. */
+    snapshots = new Map();
+    snapshotCount = 0;
+    destroyed$ = new Subject();
+    constructor(viewerService, host, sanitizer, translate) {
+        this.viewerService = viewerService;
+        this.host = host;
+        this.sanitizer = sanitizer;
+        this.translate = translate;
+    }
+    ngOnInit() {
+        // In the app's language, which the viewer's controls speak, and in its colours, as this element's
+        // styles take them from the app's - by now in the page, where they reach it.
+        const style = getComputedStyle(this.host.nativeElement);
+        const query = new URLSearchParams({
+            lang: this.translate.currentLang || 'en',
+            accent: style.color,
+            background: style.backgroundColor,
+        });
+        this.page = this.sanitizer.bypassSecurityTrustResourceUrl(`assets/viewers/splat/index.html?${query}`);
+        // The Three.js scene underneath has nothing to draw while this covers it, and the splat viewer
+        // needs all the graphics card there is.
+        this.viewerService.setThreeJsRenderingPaused(true);
+        const on = (source, next) => source.pipe(takeUntil(this.destroyed$)).subscribe(next);
+        on(this.viewerService.threeJsTagsChanged$, () => this.postTags());
+        // Placing a tag starts from the add buttons, the same in every viewer; the page picks the spot
+        // and says where ('picked').
+        on(this.viewerService.threeJsPlacementChanged$, (placing) => this.post({ type: 'placing', on: placing }));
+        on(this.viewerService.threeJsAlignmentProgress$, (progress) => {
+            this.alignment = progress;
+            this.postCalibration();
+        });
+        on(this.viewerService.threeJsAlignmentCancelled$, () => {
+            this.alignment = null;
+            this.postCalibration();
+        });
+        on(this.viewerService.threeJsMeasuringChanged$, (measuring) => this.post({ type: 'measuring', on: measuring }));
+        on(this.viewerService.threeJsMeasurementProgress$, (progress) => {
+            this.measureDistances = progress?.distances ?? [];
+            this.postMeasurement(!!progress);
+        });
+        // A finished measurement stays drawn while its form is open; this is when it goes.
+        on(this.viewerService.threeJsMeasurementCleared$, () => {
+            this.measureDistances = [];
+            this.postMeasurement(false);
+        });
+        // The camera sent to a tag, from a list: the page points it out.
+        on(this.viewerService.threeJsTagFocused$, (id) => this.post({ type: 'goToTag', id }));
+    }
+    ngOnChanges(changes) {
+        if (changes['modelKey'] && this.ready && !this.cancelled) {
+            void this.load();
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+        this.viewerService.setThreeJsRenderingPaused(false);
+        if (this.streamedMeta) {
+            URL.revokeObjectURL(this.streamedMeta);
+        }
+        this.snapshots.forEach((resolve) => resolve(null));
+        this.snapshots.clear();
+    }
+    /** Stops the model loading; nothing is loaded again until reload(). */
+    cancelLoad() {
+        this.cancelled = true;
+        this.loadedKey = null;
+        this.post({ type: 'cancel-load' });
+    }
+    /** Loads the model again, after cancelLoad. */
+    reload() {
+        this.cancelled = false;
+        this.loadedKey = null;
+        if (this.ready) {
+            void this.load();
+        }
+    }
+    setMode(mode) {
+        this.post({ type: 'mode', mode });
+    }
+    /**
+     * The scene as it is on screen, with the measurement drawn on it and no tags, as a JPEG data URL;
+     * null when there is no scene to take, or the page does not answer within ten seconds.
+     */
+    snapshot() {
+        const id = ++this.snapshotCount;
+        return new Promise((resolve) => {
+            this.snapshots.set(id, resolve);
+            this.post({ type: 'snapshot', id });
+            setTimeout(() => {
+                if (this.snapshots.delete(id)) {
+                    resolve(null);
+                }
+            }, 10000);
+        });
+    }
+    /** What the page says: that it is ready, how loading goes, what was clicked in it. */
+    onMessage(event) {
+        // Only this component's page, served from this same origin.
+        if (event.source !== this.frame?.nativeElement.contentWindow || event.origin !== window.location.origin) {
+            return;
+        }
+        const message = event.data;
+        const aligning = this.viewerService.isThreeJsAligningTags();
+        switch (message?.type) {
+            case 'ready':
+                // A new page, with nothing loaded or armed in it: the first, or the viewer starting over
+                // for the next model or after a cancelled load.
+                this.ready = true;
+                this.loadedKey = null;
+                this.pickingForCalibration = false;
+                if (!this.cancelled) {
+                    void this.load();
+                }
+                this.postTags();
+                this.postCalibration();
+                this.post({ type: 'measuring', on: this.viewerService.isThreeJsMeasuring() });
+                this.postMeasurement(this.viewerService.getThreeJsMeasurePointsInModelFrame().length > 0);
+                break;
+            case 'progress':
+                this.loadProgress.emit(message.fraction ?? null);
+                break;
+            case 'loaded':
+                this.loaded.emit();
+                break;
+            case 'error':
+                console.error('Splat viewer:', message.message);
+                this.loadFailed.emit(String(message.message ?? ''));
+                break;
+            case 'mode':
+                this.modeChange.emit(message.mode);
+                break;
+            case 'picked':
+                if (aligning && this.alignment?.awaiting === 'point') {
+                    // Where the tag being matched really is, as a click on the model in the scene would say.
+                    if (!this.viewerService.matchThreeJsAlignmentTagAtModelPoint(message.position)) {
+                        this.viewerService.ignoreThreeJsAlignmentClick('point');
+                    }
+                    break;
+                }
+                // As a click on the model in the scene: the app opens the creation form from threeJsTagPlaced$.
+                this.viewerService.placeThreeJsTagAtModelPoint(message.position, message.normal ?? null);
+                break;
+            case 'placing-cancelled':
+                // Escape, as in the scene: it ends a measurement or a calibration as it ends placing a tag.
+                if (this.viewerService.isThreeJsMeasuring()) {
+                    this.viewerService.action_toolbox_cancel_mesure();
+                }
+                else if (aligning) {
+                    this.viewerService.cancelThreeJsTagAlignment();
+                }
+                else {
+                    this.viewerService.cancelThreeJsTagPlacement();
+                }
+                break;
+            case 'calibration-undo':
+                // Ctrl+Z or Backspace in the page, as in the scene.
+                this.viewerService.undoThreeJsAlignmentStep();
+                break;
+            case 'measure-point':
+                this.viewerService.addThreeJsMeasurePointAtModelPoint(message.position);
+                break;
+            case 'tagClick':
+                if (aligning) {
+                    // Calibrating: a tag clicked is the one to match, as in the scene, and opens nothing.
+                    if (this.alignment?.awaiting !== 'tag' || !this.viewerService.selectThreeJsAlignmentTag(message.id)) {
+                        this.viewerService.ignoreThreeJsAlignmentClick('tag');
+                    }
+                    break;
+                }
+                this.viewerService.clickThreeJsTag(message.id);
+                break;
+            case 'snapshot':
+                this.snapshots.get(message.id)?.(message.image ?? null);
+                this.snapshots.delete(message.id);
+                break;
+            case 'sign': {
+                // A piece of the Streamed SOG open, by its name beside lod-meta.json.
+                const key = this.loadedKey;
+                const folder = key ? key.slice(0, key.lastIndexOf('/') + 1) : '';
+                const file = String(message.file ?? '');
+                const allowed = key && isStreamedSplatFile(key) && /^[\w.-]+$/.test(file);
+                (allowed ? getSignedFile(folder + file) : Promise.resolve(null)).then((url) => {
+                    this.post({ type: 'signed', id: message.id, url });
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    async load() {
+        const key = this.modelKey;
+        if (!key || key === this.loadedKey) {
+            return;
+        }
+        this.loadedKey = key;
+        this.loadProgress.emit(0);
+        let url = key.startsWith('assets/') ? key : await getSignedFile(key);
+        if (url && isStreamedSplatFile(key)) {
+            url = await this.streamedEntry(url);
+        }
+        if (this.loadedKey !== key) {
+            // Another model was asked for, or the load cancelled, while the link was being signed.
+            return;
+        }
+        this.post({ type: 'load', url, fileName: key.split('/').pop(), up: this.up });
+    }
+    /**
+     * The lod-meta.json of a Streamed SOG, with its pieces named so that the page asks for each of
+     * them when it needs it ('sign').
+     *
+     * The pieces sit beside lod-meta.json in S3 and are named relative to it, which a signed link -
+     * its signature in the query - does not survive. And they are fetched while the visit lasts, as the
+     * camera reaches them, long after any link signed up front has run out.
+     */
+    async streamedEntry(signedMeta) {
+        const meta = await (await fetch(signedMeta)).json();
+        meta.filenames = (meta.filenames ?? []).map((name) => `https://splat.invalid/${name}`);
+        if (this.streamedMeta) {
+            URL.revokeObjectURL(this.streamedMeta);
+        }
+        this.streamedMeta = URL.createObjectURL(new Blob([JSON.stringify(meta)], { type: 'application/json' }));
+        return this.streamedMeta;
+    }
+    postTags() {
+        const { tags, alignment } = this.viewerService.getThreeJsTagSnapshot();
+        // Tags placed elsewhere - in Matterport, in another model - are in that place's coordinates,
+        // and only a calibration says where they are in this one. Without it they float off the model
+        // and seem to slide as the camera moves: they are left out until it is calibrated. A
+        // calibration under way, or its panel open, shows them all: they are what it matches.
+        const all = this.viewerService.isThreeJsCalibrated() || this.viewerService.isThreeJsShowingCalibrationTags();
+        const shown = all ? tags : tags.filter((tag) => tag.inModelFrame);
+        this.post({
+            type: 'tags',
+            tags: shown.map(({ id, position, label, iconUrl, inModelFrame, normal }) => ({ id, position, label, iconUrl, inModelFrame, normal })),
+            alignment,
+        });
+    }
+    /**
+     * The calibration under way, for the page to draw - the pins dropped, the tag being matched - and,
+     * while the place of a tag is asked for, to take the click on the model that says where ('picked').
+     */
+    postCalibration() {
+        const on = this.viewerService.isThreeJsAligningTags() && !!this.alignment;
+        const awaiting = on ? this.alignment.awaiting : null;
+        this.post({
+            type: 'calibration',
+            calibration: on
+                ? {
+                    selected: awaiting === 'point' ? this.alignment.tagId ?? null : null,
+                    pairs: this.alignment.matched.map(({ tagId, target }) => ({ tagId, target })),
+                }
+                : null,
+        });
+        const picking = awaiting === 'point';
+        // Only when it changes: placing a tag uses the same click, and is not to be switched off here.
+        if (picking !== this.pickingForCalibration) {
+            this.pickingForCalibration = picking;
+            this.post({ type: 'placing', on: picking });
+        }
+    }
+    /** The measurement for the page to draw - its points, each segment's length - or nothing. */
+    postMeasurement(drawn) {
+        this.post({
+            type: 'measurement',
+            measurement: drawn
+                ? { points: this.viewerService.getThreeJsMeasurePointsInModelFrame(), distances: this.measureDistances }
+                : null,
+        });
+    }
+    post(command) {
+        const page = this.frame?.nativeElement.contentWindow;
+        if (page && this.ready) {
+            page.postMessage(command, window.location.origin);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SplatViewerComponent, deps: [{ token: ViewerService }, { token: i0.ElementRef }, { token: i1$3.DomSanitizer }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SplatViewerComponent, selector: "lib-splat-viewer", inputs: { modelKey: "modelKey", up: "up" }, outputs: { loadProgress: "loadProgress", loaded: "loaded", loadFailed: "loadFailed", modeChange: "modeChange" }, host: { listeners: { "window:message": "onMessage($event)" } }, viewQueries: [{ propertyName: "frame", first: true, predicate: ["frame"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: '<iframe #frame [src]="page" title="3D" allow="fullscreen; xr-spatial-tracking" allowfullscreen></iframe>', isInline: true, styles: [":host{display:block;color:var(--smarterplan-primary, rgb(83, 182, 187));background-color:var(--smarterplan-viewer-background, #e0f7ff)}iframe{display:block;width:100%;height:100%;border:0}\n"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SplatViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-splat-viewer', template: '<iframe #frame [src]="page" title="3D" allow="fullscreen; xr-spatial-tracking" allowfullscreen></iframe>', styles: [":host{display:block;color:var(--smarterplan-primary, rgb(83, 182, 187));background-color:var(--smarterplan-viewer-background, #e0f7ff)}iframe{display:block;width:100%;height:100%;border:0}\n"] }]
+        }], ctorParameters: () => [{ type: ViewerService }, { type: i0.ElementRef }, { type: i1$3.DomSanitizer }, { type: i1.TranslateService }], propDecorators: { modelKey: [{
+                type: Input
+            }], up: [{
+                type: Input
+            }], loadProgress: [{
+                type: Output
+            }], loaded: [{
+                type: Output
+            }], loadFailed: [{
+                type: Output
+            }], modeChange: [{
+                type: Output
+            }], frame: [{
+                type: ViewChild,
+                args: ['frame', { static: true }]
+            }], onMessage: [{
+                type: HostListener,
+                args: ['window:message', ['$event']]
+            }] } });
+
 class NgxSmarterplanCoreModule {
     static forRoot(config) {
         return {
@@ -16652,7 +18932,8 @@ class NgxSmarterplanCoreModule {
             NavigationBarComponent,
             LoaderComponent,
             SupportModalComponent,
-            FormatDateNumberToDigitsPipe], imports: [FormsModule,
+            FormatDateNumberToDigitsPipe,
+            SplatViewerComponent], imports: [FormsModule,
             ReactiveFormsModule,
             CommonModule,
             RouterModule,
@@ -16666,7 +18947,8 @@ class NgxSmarterplanCoreModule {
             MenuBarComponent,
             LoaderComponent,
             SupportModalComponent,
-            AvatarComponent] });
+            AvatarComponent,
+            SplatViewerComponent] });
     static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NgxSmarterplanCoreModule, imports: [FormsModule,
             ReactiveFormsModule,
             CommonModule,
@@ -16693,7 +18975,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                         NavigationBarComponent,
                         LoaderComponent,
                         SupportModalComponent,
-                        FormatDateNumberToDigitsPipe
+                        FormatDateNumberToDigitsPipe,
+                        SplatViewerComponent
                     ],
                     imports: [
                         FormsModule,
@@ -16717,6 +19000,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                         LoaderComponent,
                         SupportModalComponent,
                         AvatarComponent,
+                        SplatViewerComponent,
                     ]
                 }]
         }] });
@@ -17373,7 +19657,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }] }, { type: NavigationService }, { type: ZoneService }, { type: ViewerService }, { type: LayerService }, { type: BaseUserService }, { type: PlanService }] });
 
 /** File extensions the Three.js viewer can load as a base model. */
-const SUPPORTED_MODEL_EXTENSIONS = ['.glb', '.gltf'];
+// The splat formats open in the splat viewer, which runs in an iframe.
+const SUPPORTED_MODEL_EXTENSIONS = ['.glb', '.gltf', '.splat.ply', '.spz', '.splat', '.ksplat', '.sog', 'lod-meta.json'];
 class ThreeJsImportService {
     navigationService;
     zoneService;
@@ -17403,11 +19688,12 @@ class ThreeJsImportService {
      */
     validateModelKey(key) {
         if (!key || !key.trim()) {
-            return 'A 3D model file (.glb) is required for a Three.js visit.';
+            return 'A 3D model file is required.';
         }
         const trimmed = key.trim();
         if (!SUPPORTED_MODEL_EXTENSIONS.some((extension) => trimmed.toLowerCase().endsWith(extension))) {
-            return `The 3D model must be a ${SUPPORTED_MODEL_EXTENSIONS.join(' or ')} file.`;
+            const listed = SUPPORTED_MODEL_EXTENSIONS.slice(0, -1).join(', ');
+            return `The 3D model must be a ${listed} or ${SUPPORTED_MODEL_EXTENSIONS[SUPPORTED_MODEL_EXTENSIONS.length - 1]} file.`;
         }
         // A full https:// URL is a signed link that expires; the stored value has to be the key itself
         // so a fresh URL can be signed on every visit.
@@ -17513,6 +19799,655 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }]
         }], ctorParameters: () => [{ type: NavigationService }, { type: ZoneService }, { type: LayerService }, { type: BaseUserService }, { type: PlanService }] });
 
+/**
+ * Converts an .obj model, with its .mtl and textures, into the .glb the Three.js viewer loads - in
+ * the browser, as the model is added, with nothing to install.
+ *
+ * It does what obj2gltf did in converte-modelo.sh, and the reason is the same. An .obj lists every
+ * corner of every triangle; loaded as it is, a captured model's 2.6 million distinct vertices become
+ * 12.6 million, one per corner. Here each position and texture coordinate pair becomes one vertex,
+ * shared by every triangle that uses it, so what reaches the graphics card is the 2.6 million.
+ *
+ * Textures go in as they are, their bytes untouched: a JPEG re-encoded would lose quality and gain
+ * nothing. Normals are only written when the .obj has them; without, the viewer works them out as
+ * it loads the model. The axes are left as the .obj has them - the viewer finds which way is up.
+ *
+ * The .obj is read as a stream, so a file of hundreds of megabytes is never held whole.
+ */
+/** Whether a set of files holds an .obj model to convert. */
+function hasObjModel(files) {
+    return files.some((file) => /\.obj$/i.test(file.name));
+}
+/**
+ * Converts the .obj among `files` into a .glb, using the .mtl and the images found with it.
+ */
+async function convertObjToGlb(files, options = {}) {
+    const objs = files.filter((file) => /\.obj$/i.test(file.name));
+    if (objs.length !== 1) {
+        throw new Error(objs.length === 0 ? 'No .obj file was given.' : 'Give one .obj file at a time.');
+    }
+    const obj = objs[0];
+    const byName = new Map(files.map((file) => [baseName(file.name).toLowerCase(), file]));
+    // The .obj's own reading is most of the time; the rest is shared out over what follows.
+    const parsed = await readObj(obj.stream(), obj.size, {
+        ...options,
+        onProgress: (fraction) => options.onProgress?.(fraction * 0.85),
+    });
+    if (parsed.triangleCount === 0) {
+        throw new Error(`${obj.name} has no faces.`);
+    }
+    // Materials: from the .mtl files the .obj names, or failing that any .mtl given with it.
+    const named = parsed.materialLibraries.map((library) => byName.get(baseName(library).toLowerCase())).filter(Boolean);
+    const libraries = named.length > 0 ? named : files.filter((file) => /\.mtl$/i.test(file.name));
+    const materials = new Map();
+    for (const library of libraries) {
+        parseMtl(await library.text()).forEach((material) => materials.set(material.name, material));
+    }
+    await pause(options.signal);
+    const breaks = new Breaks(options.signal, options.onProgress);
+    const geometry = await indexGeometry(parsed, breaks);
+    options.onProgress?.(0.95);
+    await pause(options.signal);
+    const missing = new Set();
+    const glb = await writeGlb(parsed, geometry, materials, byName, missing, obj.name, breaks);
+    options.onProgress?.(1);
+    return {
+        file: new File([glb], obj.name.replace(/\.obj$/i, '') + '.glb', { type: 'model/gltf-binary' }),
+        vertices: geometry.vertexCount,
+        triangles: parsed.triangleCount,
+        materials: parsed.groups.length,
+        missingTextures: [...missing],
+    };
+}
+/** The file name without its folders, which is how an .mtl or a texture is looked up. */
+function baseName(path) {
+    return path.trim().replace(/^"|"$/g, '').split(/[\\/]/).pop() ?? path;
+}
+/** Lets the page draw and answer for a moment, and stops here if the conversion was cancelled. */
+async function pause(signal) {
+    if (signal?.aborted) {
+        throw new DOMException('Model conversion cancelled', 'AbortError');
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+ * Stops a long loop now and then so the page can draw and answer clicks. Checked only every few
+ * thousand turns of the loop: waiting on a promise every turn would cost more than the loop.
+ */
+class Breaks {
+    signal;
+    onProgress;
+    last = performance.now();
+    constructor(signal, onProgress) {
+        this.signal = signal;
+        this.onProgress = onProgress;
+    }
+    /** Whether this turn of the loop should stop for a moment. Synchronous: it is asked every turn. */
+    due(turn) {
+        return (turn & 0x3fff) === 0 && performance.now() - this.last > 40;
+    }
+    /** Stops for a moment, reporting how far the conversion has got. */
+    async take(fraction) {
+        this.onProgress?.(fraction);
+        await pause(this.signal);
+        this.last = performance.now();
+    }
+}
+/** A growable typed array: an .obj does not say up front how many of anything it holds. */
+class Growable {
+    data;
+    length = 0;
+    constructor(data) {
+        this.data = data;
+    }
+    push(value) {
+        if (this.length === this.data.length) {
+            const bigger = new this.data.constructor(this.data.length * 2);
+            bigger.set(this.data);
+            this.data = bigger;
+        }
+        this.data[this.length] = value;
+        this.length += 1;
+    }
+    view() {
+        return this.data.subarray(0, this.length);
+    }
+}
+/**
+ * Reads an .obj from a stream of its bytes: positions, texture coordinates, normals, and triangles
+ * grouped by material. Polygons are split into triangles; negative indices, counting back from the
+ * end, are resolved; anything else (objects, groups, smoothing) is skipped.
+ */
+async function readObj(stream, size, options = {}) {
+    const parser = new ObjParser();
+    const reader = stream.getReader();
+    let read = 0;
+    let lastBreak = performance.now();
+    try {
+        for (;;) {
+            if (options.signal?.aborted) {
+                throw new DOMException('Model conversion cancelled', 'AbortError');
+            }
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            parser.push(value);
+            read += value.length;
+            if (performance.now() - lastBreak > 40) {
+                options.onProgress?.(size > 0 ? Math.min(read / size, 1) : 0);
+                await new Promise((resolve) => setTimeout(resolve, 0));
+                lastBreak = performance.now();
+            }
+        }
+    }
+    finally {
+        reader.cancel().catch(() => undefined);
+    }
+    parser.end();
+    options.onProgress?.(1);
+    return parser.result();
+}
+/**
+ * Line by line, straight from the bytes. Building a string for each of the millions of lines of a
+ * captured model would be most of the work; this reads the numbers off the bytes instead.
+ */
+class ObjParser {
+    positions = new Growable(new Float64Array(1 << 16));
+    uvs = new Growable(new Float64Array(1 << 16));
+    normals = new Growable(new Float64Array(1 << 16));
+    groups = [];
+    groupByMaterial = new Map();
+    current = null;
+    materialLibraries = [];
+    triangleCount = 0;
+    /** The bytes of the line being read, kept across chunks. */
+    line = new Uint8Array(256);
+    lineLength = 0;
+    // The corners of the face being read, as position/texture/normal indices.
+    face = new Int32Array(3 * 64);
+    push(bytes) {
+        for (let index = 0; index < bytes.length; index += 1) {
+            const byte = bytes[index];
+            if (byte === 10) {
+                this.readLine();
+                this.lineLength = 0;
+            }
+            else {
+                if (this.lineLength === this.line.length) {
+                    const longer = new Uint8Array(this.line.length * 2);
+                    longer.set(this.line);
+                    this.line = longer;
+                }
+                this.line[this.lineLength] = byte;
+                this.lineLength += 1;
+            }
+        }
+    }
+    end() {
+        this.readLine();
+        this.lineLength = 0;
+    }
+    result() {
+        return {
+            positions: this.positions.view(),
+            uvs: this.uvs.view(),
+            normals: this.normals.view(),
+            groups: this.groups.filter((group) => group.corners.length > 0),
+            materialLibraries: this.materialLibraries,
+            triangleCount: this.triangleCount,
+        };
+    }
+    readLine() {
+        const line = this.line;
+        const length = this.lineLength;
+        let at = 0;
+        while (at < length && (line[at] === 32 || line[at] === 9)) {
+            at += 1;
+        }
+        if (at + 1 >= length) {
+            return;
+        }
+        const first = line[at];
+        const second = line[at + 1];
+        if (first === 118 && (second === 32 || second === 9)) {
+            // v x y z
+            this.readNumbers(at + 2, 3, this.positions);
+        }
+        else if (first === 118 && second === 116) {
+            // vt u v
+            this.readNumbers(at + 3, 2, this.uvs);
+        }
+        else if (first === 118 && second === 110) {
+            // vn x y z
+            this.readNumbers(at + 3, 3, this.normals);
+        }
+        else if (first === 102 && (second === 32 || second === 9)) {
+            this.readFace(at + 2);
+        }
+        else if (this.startsWith(at, 'usemtl')) {
+            this.useMaterial(this.restOfLine(at + 6));
+        }
+        else if (this.startsWith(at, 'mtllib')) {
+            this.materialLibraries.push(...this.restOfLine(at + 6).split(/\s+(?=\S+\.mtl\b)/i).filter(Boolean));
+        }
+    }
+    startsWith(at, word) {
+        for (let index = 0; index < word.length; index += 1) {
+            if (this.line[at + index] !== word.charCodeAt(index)) {
+                return false;
+            }
+        }
+        const after = this.line[at + word.length];
+        return after === 32 || after === 9;
+    }
+    restOfLine(at) {
+        let end = this.lineLength;
+        while (end > at && (this.line[end - 1] === 13 || this.line[end - 1] === 32 || this.line[end - 1] === 9)) {
+            end -= 1;
+        }
+        return new TextDecoder().decode(this.line.subarray(at, end)).trim();
+    }
+    useMaterial(name) {
+        let group = this.groupByMaterial.get(name);
+        if (!group) {
+            group = { material: name, corners: new Growable(new Int32Array(1 << 12)) };
+            this.groupByMaterial.set(name, group);
+            this.groups.push(group);
+        }
+        this.current = group;
+    }
+    /** Reads up to `count` numbers from `at` onwards into `target`, padding a short line with 0. */
+    readNumbers(at, count, target) {
+        let read = 0;
+        let position = at;
+        while (read < count) {
+            const [value, next] = this.readNumber(position);
+            if (next === position) {
+                break;
+            }
+            target.push(value);
+            read += 1;
+            position = next;
+        }
+        for (; read < count; read += 1) {
+            target.push(0);
+        }
+    }
+    /** Reads one number starting at or after `at`; returns it and where it ended. */
+    readNumber(at) {
+        const line = this.line;
+        const length = this.lineLength;
+        let index = at;
+        while (index < length && (line[index] === 32 || line[index] === 9 || line[index] === 13)) {
+            index += 1;
+        }
+        const start = index;
+        let negative = false;
+        if (line[index] === 45 || line[index] === 43) {
+            negative = line[index] === 45;
+            index += 1;
+        }
+        let whole = 0;
+        let fraction = 0;
+        let scale = 1;
+        let digits = 0;
+        while (index < length && line[index] >= 48 && line[index] <= 57) {
+            whole = whole * 10 + (line[index] - 48);
+            index += 1;
+            digits += 1;
+        }
+        if (line[index] === 46) {
+            index += 1;
+            while (index < length && line[index] >= 48 && line[index] <= 57) {
+                fraction = fraction * 10 + (line[index] - 48);
+                scale *= 10;
+                index += 1;
+                digits += 1;
+            }
+        }
+        if (digits === 0) {
+            return [0, at];
+        }
+        let value = whole + fraction / scale;
+        if (line[index] === 101 || line[index] === 69) {
+            index += 1;
+            let negativeExponent = false;
+            if (line[index] === 45 || line[index] === 43) {
+                negativeExponent = line[index] === 45;
+                index += 1;
+            }
+            let exponent = 0;
+            while (index < length && line[index] >= 48 && line[index] <= 57) {
+                exponent = exponent * 10 + (line[index] - 48);
+                index += 1;
+            }
+            value *= 10 ** (negativeExponent ? -exponent : exponent);
+        }
+        return [negative ? -value : value, index === start ? at : index];
+    }
+    /** f v/vt/vn ... - any of the three forms, any number of corners, split into a fan. */
+    readFace(at) {
+        const line = this.line;
+        const length = this.lineLength;
+        let corners = 0;
+        let index = at;
+        while (index < length) {
+            while (index < length && (line[index] === 32 || line[index] === 9 || line[index] === 13)) {
+                index += 1;
+            }
+            if (index >= length) {
+                break;
+            }
+            // One corner: up to three integers separated by '/', any of the last two possibly empty.
+            const values = [0, 0, 0];
+            for (let slot = 0; slot < 3; slot += 1) {
+                let negative = false;
+                if (line[index] === 45) {
+                    negative = true;
+                    index += 1;
+                }
+                let value = 0;
+                let digits = 0;
+                while (index < length && line[index] >= 48 && line[index] <= 57) {
+                    value = value * 10 + (line[index] - 48);
+                    index += 1;
+                    digits += 1;
+                }
+                values[slot] = digits === 0 ? 0 : negative ? -value : value;
+                if (line[index] !== 47) {
+                    break;
+                }
+                index += 1;
+            }
+            if (corners < 64 && values[0] !== 0) {
+                // To zero-based indices, counting a negative one back from what has been read so far; -1
+                // means "none" for the texture and normal.
+                this.face[corners * 3] = this.resolve(values[0], this.positions.length / 3);
+                this.face[corners * 3 + 1] = values[1] === 0 ? -1 : this.resolve(values[1], this.uvs.length / 2);
+                this.face[corners * 3 + 2] = values[2] === 0 ? -1 : this.resolve(values[2], this.normals.length / 3);
+                corners += 1;
+            }
+            // Skip to the next separator, past anything unexpected in this token.
+            while (index < length && line[index] !== 32 && line[index] !== 9) {
+                index += 1;
+            }
+        }
+        if (corners < 3) {
+            return;
+        }
+        if (!this.current) {
+            this.useMaterial(null);
+        }
+        const target = this.current.corners;
+        for (let corner = 1; corner + 1 < corners; corner += 1) {
+            for (const which of [0, corner, corner + 1]) {
+                target.push(this.face[which * 3]);
+                target.push(this.face[which * 3 + 1]);
+                target.push(this.face[which * 3 + 2]);
+            }
+            this.triangleCount += 1;
+        }
+    }
+    resolve(index, count) {
+        return index > 0 ? index - 1 : count + index;
+    }
+}
+/**
+ * Turns corners into shared vertices: one vertex per distinct position, texture and normal triple.
+ *
+ * Corners are grouped by position first, and the few corners that share a position are compared
+ * with one another. That needs no table of every triple ever seen - which, over millions of
+ * corners, would cost far more memory than the model itself.
+ */
+async function indexGeometry(parsed, breaks) {
+    const positionCount = parsed.positions.length / 3;
+    const groups = parsed.groups.map((group) => group.corners.view());
+    const cornerCount = groups.reduce((sum, corners) => sum + corners.length / 3, 0);
+    // Every corner, numbered across all groups, listed under its position.
+    const perPosition = new Int32Array(positionCount + 1);
+    groups.forEach((corners) => {
+        for (let at = 0; at < corners.length; at += 3) {
+            perPosition[corners[at] + 1] += 1;
+        }
+    });
+    for (let position = 0; position < positionCount; position += 1) {
+        perPosition[position + 1] += perPosition[position];
+    }
+    const filled = perPosition.slice(0, positionCount);
+    const byPosition = new Int32Array(cornerCount);
+    const cornerStart = [];
+    let numbered = 0;
+    groups.forEach((corners) => {
+        cornerStart.push(numbered);
+        for (let at = 0; at < corners.length; at += 3) {
+            byPosition[filled[corners[at]]] = numbered;
+            filled[corners[at]] += 1;
+            numbered += 1;
+        }
+    });
+    // Which group each corner is in, so its triple can be read back where it already is rather than
+    // from a copy of every corner.
+    const groupOf = new Uint16Array(cornerCount);
+    groups.forEach((corners, group) => groupOf.fill(group, cornerStart[group], cornerStart[group] + corners.length / 3));
+    const vertexOfCorner = new Uint32Array(cornerCount);
+    const sources = new Growable(new Int32Array(Math.max(16, positionCount * 3 * 1.3) | 0));
+    let vertexCount = 0;
+    for (let position = 0; position < positionCount; position += 1) {
+        if (breaks.due(position)) {
+            await breaks.take(0.85 + 0.07 * (position / positionCount));
+        }
+        const first = vertexCount;
+        for (let at = perPosition[position]; at < perPosition[position + 1]; at += 1) {
+            const corner = byPosition[at];
+            const group = groupOf[corner];
+            const triple = (corner - cornerStart[group]) * 3;
+            const uv = groups[group][triple + 1];
+            const normal = groups[group][triple + 2];
+            let found = -1;
+            for (let vertex = first; vertex < vertexCount; vertex += 1) {
+                if (sources.data[vertex * 3 + 1] === uv && sources.data[vertex * 3 + 2] === normal) {
+                    found = vertex;
+                    break;
+                }
+            }
+            if (found < 0) {
+                found = vertexCount;
+                sources.push(position);
+                sources.push(uv);
+                sources.push(normal);
+                vertexCount += 1;
+            }
+            vertexOfCorner[corner] = found;
+        }
+    }
+    return {
+        vertexCount,
+        sources: sources.view(),
+        indices: groups.map((corners, group) => vertexOfCorner.slice(cornerStart[group], cornerStart[group] + corners.length / 3)),
+    };
+}
+/** The parts of an .mtl that matter here: the colour, the opacity and the colour texture. */
+function parseMtl(text) {
+    const materials = [];
+    let current = null;
+    text.split(/\r?\n/).forEach((raw) => {
+        const line = raw.trim();
+        const [keyword, ...rest] = line.split(/\s+/);
+        if (keyword === 'newmtl') {
+            current = { name: rest.join(' '), colour: [1, 1, 1], opacity: 1, texture: null };
+            materials.push(current);
+        }
+        else if (!current) {
+            return;
+        }
+        else if (keyword === 'Kd' && rest.length >= 3) {
+            current.colour = [Number(rest[0]), Number(rest[1]), Number(rest[2])];
+        }
+        else if (keyword === 'd' && rest.length >= 1) {
+            current.opacity = Number(rest[0]);
+        }
+        else if (keyword === 'map_Kd' && rest.length >= 1) {
+            // Options (-s 1 1 1, -o ..., -bm 0.5) come before the file name, which is what is left.
+            current.texture = rest[rest.length - 1];
+        }
+    });
+    return materials;
+}
+/**
+ * Writes the .glb. The binary part is assembled from the arrays and the texture files as they are,
+ * into a Blob - so the textures are never read into memory, nor the whole file built in one buffer.
+ */
+async function writeGlb(parsed, geometry, materials, files, missing, name, breaks) {
+    const { vertexCount, sources } = geometry;
+    const hasUv = parsed.uvs.length > 0 && hasAny(sources, 1);
+    const hasNormals = parsed.normals.length > 0 && hasAny(sources, 2);
+    const positions = new Float32Array(vertexCount * 3);
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    const uvs = hasUv ? new Float32Array(vertexCount * 2) : null;
+    const normals = hasNormals ? new Float32Array(vertexCount * 3) : null;
+    for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+        if (breaks.due(vertex)) {
+            await breaks.take(0.95 + 0.04 * (vertex / vertexCount));
+        }
+        const position = sources[vertex * 3];
+        for (let axis = 0; axis < 3; axis += 1) {
+            const value = parsed.positions[position * 3 + axis];
+            positions[vertex * 3 + axis] = value;
+            min[axis] = Math.min(min[axis], Math.fround(value));
+            max[axis] = Math.max(max[axis], Math.fround(value));
+        }
+        if (uvs) {
+            const uv = sources[vertex * 3 + 1];
+            // An .obj counts v up from the bottom of the image, glTF down from the top.
+            uvs[vertex * 2] = uv >= 0 ? parsed.uvs[uv * 2] : 0;
+            uvs[vertex * 2 + 1] = uv >= 0 ? 1 - parsed.uvs[uv * 2 + 1] : 0;
+        }
+        if (normals) {
+            const normal = sources[vertex * 3 + 2];
+            for (let axis = 0; axis < 3; axis += 1) {
+                normals[vertex * 3 + axis] = normal >= 0 ? parsed.normals[normal * 3 + axis] : 0;
+            }
+        }
+    }
+    const parts = [];
+    const bufferViews = [];
+    let byteLength = 0;
+    const addView = (part, size, target) => {
+        const padding = (4 - (byteLength % 4)) % 4;
+        if (padding) {
+            parts.push(new Uint8Array(padding));
+            byteLength += padding;
+        }
+        parts.push(part);
+        bufferViews.push({ buffer: 0, byteOffset: byteLength, byteLength: size, ...(target ? { target } : {}) });
+        byteLength += size;
+        return bufferViews.length - 1;
+    };
+    const accessors = [];
+    const addAccessor = (data, type, count, extra = {}, target) => {
+        const view = addView(data, data.byteLength, target);
+        accessors.push({ bufferView: view, componentType: data instanceof Float32Array ? 5126 : 5125, count, type, ...extra });
+        return accessors.length - 1;
+    };
+    const attributes = {
+        POSITION: addAccessor(positions, 'VEC3', vertexCount, { min, max }, 34962),
+    };
+    if (normals) {
+        attributes['NORMAL'] = addAccessor(normals, 'VEC3', vertexCount, {}, 34962);
+    }
+    if (uvs) {
+        attributes['TEXCOORD_0'] = addAccessor(uvs, 'VEC2', vertexCount, {}, 34962);
+    }
+    // Materials, each texture file stored once however many materials use it.
+    const images = [];
+    const textures = [];
+    const textureOf = new Map();
+    const textureIndex = (fileName) => {
+        const key = baseName(fileName).toLowerCase();
+        if (textureOf.has(key)) {
+            return textureOf.get(key);
+        }
+        const file = files.get(key);
+        if (!file) {
+            missing.add(baseName(fileName));
+            return null;
+        }
+        const mimeType = /\.png$/i.test(file.name) ? 'image/png' : 'image/jpeg';
+        images.push({ bufferView: addView(file, file.size), mimeType, name: baseName(file.name) });
+        textures.push({ source: images.length - 1, sampler: 0 });
+        textureOf.set(key, textures.length - 1);
+        return textures.length - 1;
+    };
+    const gltfMaterials = [];
+    const primitives = parsed.groups.map((group, index) => {
+        const material = group.material !== null ? materials.get(group.material) : undefined;
+        const texture = material?.texture ? textureIndex(material.texture) : null;
+        gltfMaterials.push({
+            name: group.material ?? 'default',
+            pbrMetallicRoughness: {
+                ...(texture !== null ? { baseColorTexture: { index: texture } } : {}),
+                baseColorFactor: texture !== null ? [1, 1, 1, material?.opacity ?? 1] : [...(material?.colour ?? [0.8, 0.8, 0.8]), material?.opacity ?? 1],
+                metallicFactor: 0,
+                roughnessFactor: 1,
+            },
+            ...(material && material.opacity < 1 ? { alphaMode: 'BLEND' } : {}),
+        });
+        const triangles = geometry.indices[index];
+        return {
+            attributes,
+            indices: addAccessor(triangles, 'SCALAR', triangles.length, {}, 34963),
+            material: gltfMaterials.length - 1,
+        };
+    });
+    const json = {
+        asset: { version: '2.0', generator: 'SmarterPlan obj-to-glb' },
+        scene: 0,
+        scenes: [{ nodes: [0] }],
+        nodes: [{ mesh: 0, name: name.replace(/\.obj$/i, '') }],
+        meshes: [{ primitives }],
+        materials: gltfMaterials,
+        ...(textures.length ? {
+            textures,
+            images,
+            // Linear filtering with mipmaps, repeating: what a captured model's atlas expects.
+            samplers: [{ magFilter: 9729, minFilter: 9987, wrapS: 10497, wrapT: 10497 }],
+        } : {}),
+        accessors,
+        bufferViews,
+        buffers: [{ byteLength }],
+    };
+    let jsonBytes = new TextEncoder().encode(JSON.stringify(json));
+    const jsonPadding = (4 - (jsonBytes.length % 4)) % 4;
+    if (jsonPadding) {
+        const padded = new Uint8Array(jsonBytes.length + jsonPadding).fill(32);
+        padded.set(jsonBytes);
+        jsonBytes = padded;
+    }
+    const binPadding = (4 - (byteLength % 4)) % 4;
+    const binLength = byteLength + binPadding;
+    const header = new DataView(new ArrayBuffer(12 + 8));
+    header.setUint32(0, 0x46546c67, true); // "glTF"
+    header.setUint32(4, 2, true);
+    header.setUint32(8, 12 + 8 + jsonBytes.length + 8 + binLength, true);
+    header.setUint32(12, jsonBytes.length, true);
+    header.setUint32(16, 0x4e4f534a, true); // "JSON"
+    const binHeader = new DataView(new ArrayBuffer(8));
+    binHeader.setUint32(0, binLength, true);
+    binHeader.setUint32(4, 0x004e4942, true); // "BIN"
+    return new Blob([header, jsonBytes, binHeader, ...parts, new Uint8Array(binPadding)]);
+}
+/** Whether any vertex uses the given slot of its source triple (texture or normal). */
+function hasAny(sources, slot) {
+    for (let at = slot; at < sources.length; at += 3) {
+        if (sources[at] >= 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
 // matterport-transform.util.ts
 /**
  * Computes the rigid transform (Y-axis rotation + translation) between two
@@ -20487,5 +23422,5 @@ function floatValidator() {
  * Generated bundle index. Do not edit.
  */
 
-export { AffectationService, AvatarComponent, BaseLateralTabService, BaseTagService, BaseUserService, BaseVisibilityService, CameraMode, CaptureService, CaptureViewer, CommentService, CommentType, Config, ContentService, CsvExportComponent, DomainService, DomainType, DurationToStringPipe, EmailStatus, EquipmentService, EventService, EventStatus, EventType, FeatureService, FeatureType, FilterService, HashtagFromIdPipe, HashtagService, InterventionService, InventoryStatus, LayerService, LevelStatus, LoaderComponent, Locale, LocaleService, MATTERPORT_SDK_KEY, MatterportImportService, MatterportService, MatterportTagCopyService, MatterportViewType, MattertagActionMode, MattertagData, MeasurementService, MenuBarComponent, MissionService, NavigationService, NavigatorService, NgxSmarterplanCoreModule, NgxSmarterplanCoreService, NodeService, Object3DService, OperationService, OrganisationService, PaymentStatus, PlanService, PoiService, PoiType, ProfileEntity, ProfileService, ProfileStatus, PropertyService, PropertyType, RoleStatus, SafeUrlPipe, SearchBarComponent, SearchObjectType, SearchService, SpModule, SpaceService, SpaceStatus, StatusEquipment, SupportModalComponent, SupportService, SweepLocatorService, THREEJS_MODEL_UP_OPTIONS, TagAction, TemplateService, ThreeJsImportService, ThreeJsService, TicketPriority, TicketStatus, TicketType, TicketsService, TimeDateToLocalStringPipe, TypeNote, UsernameFromIdPipe, ValidatorsService, ViewerInteractions, ViewerService, VisitService, ZoneChangeService, ZoneService, applyRigidTransformToDirection, applyRigidTransformToPoint, applyRigidTransformToYRotationDeg, arraysContainSameElements, checkElementById, computeRigidTransform, convertTimestampToLocalZone, copyFileInS3, copyFileInS3ViaDownload, dateHasExpired, dateTimeToLocalString, deleteFromS3, distance, downloadBlob, downloadEquipmentDocument, downloadFile, downloadFileAsObject, durationToString, emailValidator, enumToArray, filterUniqueArrayByID, floatValidator, getBufferForFileFromS3, getCoefficientsForImage, getCurrentLang, getDistanceBetweenTwoPoints, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getLocaleLong, getLocaleShort, getMetaForImage, getRolesBelowForManager, getSignedFile, getSignedImageUrlForEquipment, getSignedImageUrlForProfile, getSignedImageUrlForSpace, getSpaceIDFromUrl, getThreeJsPoiOrigin, getVisitUrl, isEmptyObject, listFilesInFolder, mean, noEmptyValidator, numberToDateString, openDocument, openModalForVisitSwitch, parseThreeJsPlacement, poiTypeToString, pointToString, removeAllFilesFromFolderS3, removeNullKeysFromObject, showScanPointsOnPlanInDiv, shuffleArray, solveThreeJsAlignment, sortAlphabeticallyOnName, stringLocaleToEnum, stringToLowercaseNoSpaces, styleButton, textValidator, translateDatePeriod, uploadBase64Image, uploadBase64ImageWithRetry, uploadFileToS3, uploadFileToS3WithProgress, uploadJsonToS3, validEmail, wait, waitUntil };
+export { AffectationService, AvatarComponent, BaseLateralTabService, BaseTagService, BaseUserService, BaseVisibilityService, CameraMode, CaptureService, CaptureViewer, CommentService, CommentType, Config, ContentService, CsvExportComponent, DomainService, DomainType, DurationToStringPipe, EmailStatus, EquipmentService, EventService, EventStatus, EventType, FeatureService, FeatureType, FilterService, GAUSSIAN_SPLAT_PLY_SUFFIX, HashtagFromIdPipe, HashtagService, InterventionService, InventoryStatus, LayerService, LevelStatus, LoaderComponent, Locale, LocaleService, MATTERPORT_SDK_KEY, MatterportImportService, MatterportService, MatterportTagCopyService, MatterportViewType, MattertagActionMode, MattertagData, MeasurementService, MenuBarComponent, MissionService, NavigationService, NavigatorService, NgxSmarterplanCoreModule, NgxSmarterplanCoreService, NodeService, Object3DService, OperationService, OrganisationService, PaymentStatus, PlanService, PoiService, PoiType, ProfileEntity, ProfileService, ProfileStatus, PropertyService, PropertyType, RoleStatus, SafeUrlPipe, SearchBarComponent, SearchObjectType, SearchService, SpModule, SpaceService, SpaceStatus, SplatViewerComponent, StatusEquipment, SupportModalComponent, SupportService, SweepLocatorService, THREEJS_MODEL_UP_OPTIONS, TagAction, TemplateService, ThreeJsImportService, ThreeJsService, TicketPriority, TicketStatus, TicketType, TicketsService, TimeDateToLocalStringPipe, TypeNote, UsernameFromIdPipe, VIEWER_BACKGROUND, ValidatorsService, ViewerInteractions, ViewerService, VisitService, ZoneChangeService, ZoneService, applyRigidTransformToDirection, applyRigidTransformToPoint, applyRigidTransformToYRotationDeg, arraysContainSameElements, checkElementById, computeRigidTransform, convertObjToGlb, convertTimestampToLocalZone, copyFileInS3, copyFileInS3ViaDownload, dateHasExpired, dateTimeToLocalString, deleteFromS3, distance, downloadBlob, downloadEquipmentDocument, downloadFile, downloadFileAsObject, durationToString, emailValidator, enumToArray, filterUniqueArrayByID, floatValidator, getBufferForFileFromS3, getCoefficientsForImage, getCurrentLang, getDistanceBetweenTwoPoints, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getLocaleLong, getLocaleShort, getMetaForImage, getRolesBelowForManager, getSignedFile, getSignedImageUrlForEquipment, getSignedImageUrlForProfile, getSignedImageUrlForSpace, getSpaceIDFromUrl, getThreeJsPoiOrigin, getVisitUrl, hasObjModel, isEmptyObject, isGaussianSplatFile, isGaussianSplatPly, isStreamedSplatFile, listFilesInFolder, mean, noEmptyValidator, numberToDateString, openDocument, openModalForVisitSwitch, parseThreeJsPlacement, poiTypeToString, pointToString, readObj, removeAllFilesFromFolderS3, removeNullKeysFromObject, showScanPointsOnPlanInDiv, shuffleArray, solveThreeJsAlignment, sortAlphabeticallyOnName, stringLocaleToEnum, stringToLowercaseNoSpaces, styleButton, textValidator, translateDatePeriod, uploadBase64Image, uploadBase64ImageWithRetry, uploadFileToS3, uploadFileToS3WithProgress, uploadJsonToS3, validEmail, wait, waitUntil };
 //# sourceMappingURL=smarterplan-ngx-smarterplan-core.mjs.map