@smarterplan/ngx-smarterplan-core 1.4.19 → 1.4.21

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

@@ -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';
@@ -20,6 +20,9 @@ import { MTLLoader } from 'three/examples/jsm/loaders/MTLLoader';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
 import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';
 import { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';
+import { Line2 } from 'three/examples/jsm/lines/Line2';
+import { LineGeometry } from 'three/examples/jsm/lines/LineGeometry';
+import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial';
 import * as FileSaver from 'file-saver';
 import levenshtein from 'js-levenshtein';
 import { GlobalWorkerOptions, getDocument } from 'pdfjs-dist';
@@ -383,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;
@@ -630,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();
     }
@@ -669,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;
@@ -678,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);
@@ -722,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,
@@ -742,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({
@@ -2290,6 +2316,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;
@@ -3460,6 +3549,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);
@@ -3470,112 +3581,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);
@@ -3595,10 +3778,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,
         };
@@ -3607,9 +3812,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);
@@ -3619,49 +3831,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;
@@ -4358,6 +4970,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;
@@ -4378,6 +4992,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;
     }
@@ -4519,6 +5145,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) {
@@ -4532,8 +5162,7 @@ class MatterportService {
     };
     pointerRightClickHandler = (e) => {
         e.preventDefault();
-        this.cancelFollowingCursor();
-        alert('action cancelled');
+        this.cancelCurrentPlacement();
     };
     pointerMiddleClickHandler = (e) => {
         this.pointerService.updateCursorDisplay(this.poseMatterport);
@@ -4580,6 +5209,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 () => {
@@ -4656,6 +5286,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);
                     }
@@ -4681,6 +5314,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
@@ -4792,7 +5430,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
                 */
@@ -4864,7 +5502,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.
@@ -5293,6 +5931,9 @@ class MatterportService {
      * @param uuid
      */
     async deleteObject3D(uuid) {
+        if (this.object3DPlacement?.uuid === uuid) {
+            this.cancelObject3DPlacement();
+        }
         return this.object3DService.deleteObject3D(uuid);
     }
     getObject3DModelNodeFromDictionnary(uuid) {
@@ -5337,6 +5978,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);
     }
@@ -5705,7 +6351,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;
@@ -5729,6 +6378,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);
     }
@@ -5738,7 +6390,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) {
@@ -5753,61 +6441,314 @@ 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.
- */
-function frameFromPoints(a, b, c) {
-    const e1 = b.clone().sub(a);
-    if (e1.lengthSq() < 1e-12) {
-        return null;
+    setViewFrustum(uuid, visible) {
+        return this.object3DService.setViewFrustum(uuid, visible);
     }
-    e1.normalize();
-    const toC = c.clone().sub(a);
-    const e2 = toC.clone().sub(e1.clone().multiplyScalar(toC.dot(e1)));
-    if (e2.lengthSq() < 1e-12) {
-        return null;
+    isViewFrustumVisible(uuid) {
+        return this.object3DService.isViewFrustumVisible(uuid);
     }
-    e2.normalize();
-    return new THREE.Matrix4().makeBasis(e1, e2, e1.clone().cross(e2));
+    //
+    // ---------- 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);
+    if (e1.lengthSq() < 1e-12) {
+        return null;
+    }
+    e1.normalize();
+    const toC = c.clone().sub(a);
+    const e2 = toC.clone().sub(e1.clone().multiplyScalar(toC.dot(e1)));
+    if (e2.lengthSq() < 1e-12) {
+        return null;
+    }
+    e2.normalize();
+    return new THREE.Matrix4().makeBasis(e1, e2, e1.clone().cross(e2));
 }
 /**
- * Solves the transform that maps stored tag coordinates onto the loaded model.
+ * Solves the transform that maps stored tag coordinates onto the loaded model, from as many matched
+ * tags as there are - up to three.
+ *
+ * Three pairs pin down everything: position, orientation and scale. A model that shares only a
+ * corner with the tags' space may not have three tags to offer, so fewer are accepted, each
+ * settling what it can and assuming the rest:
  *
- * Takes exactly the correspondences a person can produce by hand: three tags, each pointed at twice
- * - once where it currently sits, once where it belongs. That is the minimum that pins down all
- * three parts of the answer. One pair fixes only translation; two leave the rotation about the line
- * between them free; three resolve it.
+ *  - Two pairs: position, heading and scale. The one thing two points cannot say is how the model
+ *    is tilted, so both spaces are taken to agree on which way is up.
+ *  - One pair: position only. Heading and scale are taken to match already.
  *
- * Returns null when the points are collinear or degenerate, because a wrong alignment applied
- * silently is worse than none.
+ * `targetUp` is the model's vertical axis, which the tags' own vertical (+Y) is matched to in those
+ * two cases. Returns null when the points cannot answer the question asked of them - collinear for
+ * three, one above the other for two - because a wrong calibration applied silently is worse than
+ * none.
  */
-function solveThreeJsAlignment(pairs) {
-    if (!pairs || pairs.length < 3) {
+function solveThreeJsAlignment(pairs, targetUp = { x: 0, y: 1, z: 0 }) {
+    if (!pairs || pairs.length === 0) {
         return null;
     }
+    if (pairs.length < 3) {
+        return solveReducedAlignment(pairs, new THREE.Vector3(targetUp.x, targetUp.y, targetUp.z).normalize());
+    }
     const sources = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));
     const targets = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));
     const sourceFrame = frameFromPoints(sources[0], sources[1], sources[2]);
@@ -5848,6 +6789,41 @@ function solveThreeJsAlignment(pairs) {
         scale,
     };
 }
+/** The one- and two-pair cases of solveThreeJsAlignment, which share the "same vertical" assumption. */
+function solveReducedAlignment(pairs, up) {
+    const sources = pairs.map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));
+    const targets = pairs.map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));
+    // Starts from the rotation that only stands the tags' vertical on the model's.
+    const rotation = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), up);
+    let scale = 1;
+    if (pairs.length === 2) {
+        const sourceSpan = sources[1].clone().sub(sources[0]);
+        const targetSpan = targets[1].clone().sub(targets[0]);
+        if (sourceSpan.length() < 1e-9 || targetSpan.length() < 1e-9) {
+            return null;
+        }
+        scale = targetSpan.length() / sourceSpan.length();
+        // Heading is the turn about the vertical that lines the two spans up, so only their horizontal
+        // parts count. Two points one above the other have none, and say nothing about heading.
+        const flatten = (v) => v.clone().sub(up.clone().multiplyScalar(v.dot(up)));
+        const from = flatten(sourceSpan.clone().applyQuaternion(rotation));
+        const to = flatten(targetSpan);
+        if (from.length() < 1e-6 * sourceSpan.length() || to.length() < 1e-6 * targetSpan.length()) {
+            return null;
+        }
+        const heading = Math.atan2(new THREE.Vector3().crossVectors(from, to).dot(up), from.dot(to));
+        rotation.premultiply(new THREE.Quaternion().setFromAxisAngle(up, heading));
+    }
+    // A point lands at t + s*R*p; solved for t at the centroids, as in the three-pair case.
+    const centroid = (points) => points.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / points.length);
+    const translation = centroid(targets).sub(centroid(sources).applyQuaternion(rotation).multiplyScalar(scale));
+    const euler = new THREE.Euler().setFromQuaternion(rotation);
+    return {
+        translation: { x: translation.x, y: translation.y, z: translation.z },
+        rotation: { x: euler.x, y: euler.y, z: euler.z },
+        scale,
+    };
+}
 class ThreeJsService {
     ngZone;
     scene;
@@ -5885,6 +6861,61 @@ class ThreeJsService {
     pendingTagPlacement = null;
     /** Pointer position waiting for a preview pick, coalesced to one per frame. */
     pendingPreviewEvent = null;
+    /**
+     * Tags whose position is in this model's own coordinates. A sibling of the tag group that does not
+     * carry the calibration: calibrating a model for the tags it imports must not move the ones that
+     * were placed straight onto it.
+     */
+    modelTagGroup = new THREE.Group();
+    /**
+     * The capture on screen. A tag placed in a 3D model is recorded with it, which is how the tags
+     * placed in this one are told from those that came from elsewhere.
+     */
+    currentCaptureID = null;
+    /**
+     * The model's surface as a grid: every cell some part of the surface passes through.
+     *
+     * It answers "is this point near the model?" without visiting the triangles, of which a captured
+     * model has millions - the question is asked for every tag, every time the calibration changes.
+     */
+    surfaceCells = null;
+    surfaceOrigin = new THREE.Vector3();
+    surfaceCellSize = 1;
+    /**
+     * How far from the model's surface a tag may be and still count as on it, in metres.
+     *
+     * Every tag of the space is offered to every model; this is what decides which ones a model
+     * shows. A tag marks something on a surface, so one that belongs here sits on the surface or
+     * close to it. One that lands deep inside the model, or well away from it, marks something that
+     * is not part of this model. The allowance covers a calibration done by hand and the model not
+     * matching the scan exactly, which together run to a few tens of centimetres.
+     */
+    static ON_MODEL_METRES = 0.75;
+    /** Cells per axis the grid's keys can address, with room either side for points off the model. */
+    static SURFACE_GRID_SPAN = 1024;
+    static SURFACE_GRID_PAD = 128;
+    /** Own tags moved to keep their place under the last calibration, waiting to be stored. */
+    rebasedTags = [];
+    /** The type filter in force. Null shows every type. */
+    visibleTagTypes = null;
+    measuring = false;
+    /** Points clicked so far, in tag space. */
+    measurePoints = [];
+    /**
+     * Everything drawn for the measurement. A child of the tag group, so its points share the frame
+     * tag coordinates are stored in - which is metres, and what the saved POI has to be in.
+     */
+    measureGroup = new THREE.Group();
+    /** The segment that follows the pointer from the last point clicked. */
+    measureRubberBand;
+    lastMeasurement = null;
+    /** Half the model's diagonal as placed in the scene, where it is centred on the origin. */
+    modelWorldRadius = 0;
+    /** The outermost group the model and its tags hang from: where "which way is up" is applied. */
+    modelGroup;
+    modelUp = 'y';
+    /** While measuring: how many points and each segment's length. Null when it is abandoned. */
+    measurementProgress$ = new Subject();
     /**
      * Layer carrying the model alone, so the depth pick can render it without the tags.
      *
@@ -5892,6 +6923,8 @@ class ThreeJsService {
      * their parent passed, so marking the model's own meshes is enough - no re-parenting.
      */
     static PICK_LAYER = 1;
+    /** The app's highlight colour, so a measurement reads as the active thing on screen. */
+    static MEASURE_COLOR = '#FFB103';
     /** Cache Storage bucket holding downloaded models, and how many to keep. */
     static MODEL_CACHE = 'smarterplan-3d-models';
     static MODEL_CACHE_SIZE = 3;
@@ -5908,6 +6941,8 @@ class ThreeJsService {
     aligning = false;
     alignmentPairs = [];
     alignmentSource = null;
+    /** The tag `alignmentSource` was read from, kept so the same tag is not matched twice. */
+    alignmentSourceTagId;
     /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */
     alignmentProgress$ = new Subject();
     /** In-flight camera move started by goToTag, advanced by the render loop. */
@@ -6023,6 +7058,8 @@ class ThreeJsService {
         //    new model and show the previous visit's tags on it.
         this.discardCurrentLoad();
         this.clearTags();
+        this.measuring = false;
+        this.clearMeasurement();
         this.cameraTween = null;
         this.modelRoot = undefined;
         // 1. Setup Scene
@@ -6130,7 +7167,7 @@ class ThreeJsService {
      * and stays indexed, so far less data reaches the GPU. KTX2 textures are supported too: they
      * stay compressed in VRAM instead of being decoded to raw pixels like JPEG/PNG.
      */
-    loadGLTFModel(url, cameraPosition, rotation, cacheKey) {
+    loadGLTFModel(url, cameraPosition, rotation, cacheKey, up) {
         const loader = new GLTFLoader();
         // KTX2 needs the renderer to report which compressed formats this GPU accepts, so this has to
         // happen after init(). Guarded so a model without KTX2 textures still loads if it's missing.
@@ -6156,7 +7193,7 @@ class ThreeJsService {
             this.forceDoubleSidedMaterials(gltf.scene);
             this.ensureVertexNormals(gltf.scene);
             this.tuneTextureSampling(gltf.scene);
-            this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation);
+            this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation, up);
             this.modelLoading$.next(false);
         };
         const onError = (error) => {
@@ -6629,7 +7666,7 @@ class ThreeJsService {
         });
     }
     /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */
-    placeLoadedObjectInScene(object, cameraPosition, rotation) {
+    placeLoadedObjectInScene(object, cameraPosition, rotation, up) {
         const box = new THREE.Box3().setFromObject(object);
         const center = box.getCenter(new THREE.Vector3());
         const size = box.getSize(new THREE.Vector3());
@@ -6644,12 +7681,25 @@ class ThreeJsService {
         if (rotation) {
             object.rotation.set(rotation.x, rotation.y, rotation.z);
         }
+        // Which way is up. A choice someone made by hand always wins; otherwise, unless the model came
+        // with an orientation of its own, it is worked out from the geometry. Applied to the outer
+        // group, above both the model and the tags: they turn together, and every coordinate already
+        // stored - tag positions, the calibration - keeps meaning what it meant.
+        this.modelGroup = group;
+        this.modelUp = up ?? (rotation ? 'y' : this.detectModelUp(object, size));
+        group.quaternion.copy(this.uprightRotation(this.modelUp));
         this.modelRoot = object;
+        this.modelWorldRadius = (size.length() / 2) * scale;
+        // The box above was measured before any rotation from the metadata was applied; with one, it
+        // has to be measured again to be the model as it actually sits.
+        this.buildSurfaceGrid(object, rotation ? new THREE.Box3().setFromObject(object) : box);
+        this.refreshTagVisibility();
         // Marks the model for the depth pick, which renders this layer alone - so tags and the ghost
         // itself cannot end up being what the cursor reports as the surface under it.
         object.traverse((child) => child.layers.enable(ThreeJsService.PICK_LAYER));
         centered.add(object);
         centered.add(this.tagGroup);
+        centered.add(this.modelTagGroup);
         group.add(centered);
         group.scale.setScalar(scale);
         this.scene.add(group);
@@ -6665,6 +7715,98 @@ class ThreeJsService {
         this.controls.target.set(0, 0, 0);
         this.controls.update();
     }
+    /**
+     * Which of the model's axes is its vertical: 'y' when it already stands upright, or when it is
+     * 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:
+     *
+     *  - 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.
+     *
+     * 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.
+     */
+    detectModelUp(object, size) {
+        const axes = ['x', 'y', 'z'];
+        // Projected area facing each way along each axis: [positive, negative].
+        const area = { x: [0, 0], y: [0, 0], z: [0, 0] };
+        let triangleCount = 0;
+        object.updateMatrixWorld(true);
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (position) {
+                triangleCount += (child.geometry.index ? child.geometry.index.count : position.count) / 3;
+            }
+        });
+        if (triangleCount === 0) {
+            return 'y';
+        }
+        // A sample is plenty to see where the area lies, and keeps this cheap on models with millions
+        // of triangles.
+        const stride = Math.max(1, Math.ceil(triangleCount / 200000));
+        const a = new THREE.Vector3();
+        const b = new THREE.Vector3();
+        const c = new THREE.Vector3();
+        const normal = new THREE.Vector3();
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (!position) {
+                return;
+            }
+            const index = child.geometry.index;
+            const count = (index ? index.count : position.count) / 3;
+            for (let triangle = 0; triangle < count; triangle += stride) {
+                const offset = triangle * 3;
+                a.fromBufferAttribute(position, index ? index.getX(offset) : offset).applyMatrix4(child.matrixWorld);
+                b.fromBufferAttribute(position, index ? index.getX(offset + 1) : offset + 1).applyMatrix4(child.matrixWorld);
+                c.fromBufferAttribute(position, index ? index.getX(offset + 2) : offset + 2).applyMatrix4(child.matrixWorld);
+                // The cross product's length is twice the triangle's area, so its components are the
+                // area the triangle shows along each axis.
+                normal.crossVectors(b.sub(a), c.sub(a));
+                axes.forEach((axis) => {
+                    area[axis][normal[axis] >= 0 ? 0 : 1] += Math.abs(normal[axis]);
+                });
+            }
+        });
+        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) {
+            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}`;
+        console.info(`ThreeJsService: this model's vertical axis looks like ${up}, not y - standing it upright.`);
+        return up;
+    }
+    /** The rotation that brings the given model axis to point up. */
+    uprightRotation(up) {
+        const axis = new THREE.Vector3();
+        axis[up.replace('-', '')] = up.startsWith('-') ? -1 : 1;
+        return new THREE.Quaternion().setFromUnitVectors(axis, new THREE.Vector3(0, 1, 0));
+    }
+    /** Which of the model's axes is currently treated as up, whether chosen or worked out. */
+    getModelUp() {
+        return this.modelUp;
+    }
+    /**
+     * Turns the model so the given axis points up, at once.
+     *
+     * The model and its tags turn as one, so nothing stored has to be recomputed. The caller is
+     * expected to store the choice, or the next load goes back to working it out.
+     */
+    setModelUp(up) {
+        this.modelUp = up;
+        this.modelGroup?.quaternion.copy(this.uprightRotation(up));
+    }
     /**
      * Keeps the drawing buffer and camera matched to the canvas as it is resized.
      *
@@ -6690,6 +7832,7 @@ class ThreeJsService {
             this.camera.aspect = width / height;
             this.camera.updateProjectionMatrix();
             this.renderer.setSize(width, height);
+            this.updateMeasureLineResolution();
         });
         this.canvasResizeObserver.observe(container);
     }
@@ -6701,9 +7844,16 @@ class ThreeJsService {
      * applied until solveAlignmentFromPairs() succeeds.
      */
     startTagAlignment() {
+        // One pointer mode at a time, the same rule startMeasuring() applies the other way round.
+        if (this.measuring) {
+            this.cancelMeasuring();
+        }
         this.aligning = true;
         this.alignmentPairs = [];
         this.alignmentSource = null;
+        // 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';
         }
@@ -6716,6 +7866,7 @@ class ThreeJsService {
         this.alignmentSource = null;
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
+        this.refreshTagVisibility();
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'default';
         }
@@ -6735,12 +7886,22 @@ class ThreeJsService {
      * first half of a pair, which is a click on a tag, not on the model.
      */
     isPreviewingPlacement() {
-        return this.placingTag || (this.aligning && !!this.alignmentSource);
+        return this.placingTag || this.measuring || (this.aligning && !!this.alignmentSource);
     }
     /** Whether a tag is currently registered for this element. */
     hasTag(elementId) {
         return this.tagSprites.has(elementId);
     }
+    /** How many tags are on show - the ones a person could actually click. */
+    getTagCount() {
+        let visible = 0;
+        this.tagSprites.forEach((sprite) => {
+            if (sprite.visible) {
+                visible += 1;
+            }
+        });
+        return visible;
+    }
     /**
      * Solves and applies the alignment collected so far, returning it so the caller can persist it.
      *
@@ -6748,35 +7909,105 @@ class ThreeJsService {
      * the walkthrough stays open for the person to pick a better third point.
      */
     solveAlignmentFromPairs() {
-        const alignment = solveThreeJsAlignment(this.alignmentPairs);
+        const up = new THREE.Vector3();
+        up[this.modelUp.replace('-', '')] = this.modelUp.startsWith('-') ? -1 : 1;
+        const alignment = solveThreeJsAlignment(this.alignmentPairs, up);
         if (!alignment) {
             return null;
         }
-        this.setTagAlignment(alignment);
+        // 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.applyAlignmentKeepingOwnTags(alignment);
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
         this.renderer.domElement.style.cursor = 'default';
         this.alignmentProgress$.next({ pairs: this.alignmentPairs.length, awaiting: null });
         return alignment;
     }
+    /**
+     * Applies a new calibration while keeping every tag placed in this model exactly where it is.
+     *
+     * A calibration is worked out for the tags that came from elsewhere. The model's own tags were put
+     * where they are by someone clicking the model, so they must not follow it. Their stored
+     * coordinates are rewritten instead: into the shared space as the new calibration defines it.
+     * That is also what makes them comparable with other visits from here on - a tag placed before
+     * the model was calibrated was in the model's own coordinates, visible nowhere else.
+     *
+     * The rewritten tags are kept for the caller to store; see takeRebasedTags().
+     */
+    applyAlignmentKeepingOwnTags(alignment) {
+        const own = [...this.tagSprites.values()].filter((sprite) => this.isOwnedByVisit(sprite));
+        // Where each one is now, in the space the model sits in, and how its parent was turned.
+        const placed = own.map((sprite) => {
+            sprite.parent?.updateMatrix();
+            return {
+                sprite,
+                position: sprite.position.clone().applyMatrix4(sprite.parent?.matrix ?? new THREE.Matrix4()),
+                turn: sprite.parent?.quaternion.clone() ?? new THREE.Quaternion(),
+            };
+        });
+        this.setTagAlignment(alignment);
+        const inverse = this.tagGroup.matrix.clone().invert();
+        const unturn = this.tagGroup.quaternion.clone().invert();
+        this.rebasedTags = placed.map(({ sprite, position, turn }) => {
+            sprite.position.copy(position.applyMatrix4(inverse));
+            sprite.userData.frame = null;
+            this.parentTag(sprite);
+            this.scaleTagForModel(sprite);
+            const rotation = unturn.clone().multiply(turn);
+            return {
+                id: sprite.name,
+                position: { x: sprite.position.x, y: sprite.position.y, z: sprite.position.z },
+                rotateDirection: ({ x, y, z }) => {
+                    const turned = new THREE.Vector3(x, y, z).applyQuaternion(rotation);
+                    return { x: turned.x, y: turned.y, z: turned.z };
+                },
+            };
+        });
+        this.refreshTagVisibility();
+    }
+    /** Hands over the tags the last calibration rewrote, once, for them to be stored. */
+    takeRebasedTags() {
+        const rebased = this.rebasedTags;
+        this.rebasedTags = [];
+        return rebased;
+    }
+    /**
+     * Chooses the tag for the pair being matched by id, instead of by clicking it.
+     *
+     * Clicking a tag supposes it can be found. On a model that has never been calibrated the tags may
+     * sit far from it, or all on top of one another; a list has neither problem.
+     */
+    selectAlignmentTag(elementId) {
+        const sprite = this.tagSprites.get(elementId);
+        if (!this.aligning || this.alignmentSource || !sprite || !this.calibrationCandidates().includes(sprite)) {
+            return false;
+        }
+        this.setAlignmentSource(sprite);
+        return true;
+    }
+    setAlignmentSource(sprite) {
+        // The sprite's own position is the stored coordinate, untouched by any alignment already
+        // applied - that transform lives on the group, not on the sprite.
+        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,
+        });
+    }
     /** 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?
-            const hit = this.raycaster.intersectObjects(this.tagGroup.children, false)[0];
+            const hit = this.raycaster.intersectObjects(this.calibrationCandidates(), false)[0];
             if (!hit) {
                 return;
             }
-            // The sprite's own position is the stored coordinate, untouched by any alignment already
-            // applied - that transform lives on the group, not on the sprite.
-            const stored = hit.object.position;
-            this.alignmentSource = { x: stored.x, y: stored.y, z: stored.z };
-            this.alignmentProgress$.next({
-                pairs: this.alignmentPairs.length,
-                awaiting: 'point',
-                tagId: hit.object.name,
-            });
+            this.setAlignmentSource(hit.object);
             return;
         }
         // Second half: where that tag actually belongs on the model.
@@ -6784,83 +8015,319 @@ class ThreeJsService {
         if (!target) {
             return;
         }
-        this.alignmentPairs.push({ source: this.alignmentSource, target });
+        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.pendingPreviewEvent = null;
         this.removePlacementPreview();
         this.alignmentProgress$.next({
             pairs: this.alignmentPairs.length,
-            awaiting: this.alignmentPairs.length >= 3 ? null : 'tag',
+            // 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',
         });
     }
-    /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
-    startTagPlacement(poiType = null) {
-        this.placingTag = true;
-        this.placementPoiType = poiType;
-        this.pendingTagPlacement = null;
+    /**
+     * Starts a measurement: every click on the model adds a point, and each pair of consecutive
+     * points is a measured segment.
+     *
+     * It ends through finishMeasuring() or cancelMeasuring() rather than on its own after two points,
+     * because a measurement may have several segments - the same as Matterport's, whose results are
+     * stored as a list of distances.
+     */
+    startMeasuring() {
+        // One pointer mode at a time: a click cannot be both a tag position and a measured point.
+        this.cancelTagPlacement();
+        if (this.aligning) {
+            this.cancelTagAlignment();
+        }
+        this.clearMeasurement();
+        if (this.measureGroup.parent !== this.tagGroup) {
+            this.tagGroup.add(this.measureGroup);
+        }
+        this.measuring = true;
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'crosshair';
         }
+        this.measurementProgress$.next({ points: 0, distances: [] });
     }
-    /** Leaves placement mode without placing anything. */
-    cancelTagPlacement() {
-        this.placingTag = false;
-        this.pendingTagPlacement = null;
+    /**
+     * Abandons the measurement and removes what was drawn.
+     *
+     * Also what clears a finished measurement off the model once its form is saved or closed, which
+     * is why it only reports an abandonment when one was actually in progress.
+     */
+    cancelMeasuring() {
+        const wasMeasuring = this.measuring;
+        this.measuring = false;
         this.pendingPreviewEvent = null;
         this.removePlacementPreview();
+        this.clearMeasurement();
+        // Forgotten here so that a form opened later cannot pick up a measurement already dealt with.
+        this.lastMeasurement = null;
         if (this.renderer) {
             this.renderer.domElement.style.cursor = 'default';
         }
+        if (wasMeasuring) {
+            this.measurementProgress$.next(null);
+        }
     }
     /**
-     * Shows a translucent tag under the cursor while placing, so the spot is visible before commiting.
+     * Ends the measurement and returns it, or null when there are not yet two points to measure
+     * between - in which case measuring simply carries on.
      *
-     * Matterport does this with a tag that follows the pointer; the equivalent here is a preview
-     * sprite that gets removed the moment the real tag takes its place.
+     * The drawing stays on the model so it is still visible while the person names the measurement;
+     * cancelMeasuring() takes it away afterwards.
      */
-    updatePlacementPreview(event) {
-        const position = this.pickPointOnGpu(event);
-        if (!position) {
-            this.removePlacementPreview();
-            this.renderer.domElement.style.cursor = 'not-allowed';
-            return;
+    finishMeasuring() {
+        if (!this.measuring || this.measurePoints.length < 2) {
+            return null;
         }
-        this.renderer.domElement.style.cursor = 'crosshair';
-        if (!this.placementPreview) {
-            this.placementPreview = new THREE.Sprite(new THREE.SpriteMaterial({
-                map: this.createTagTexture('#9E9E9E'),
+        this.measuring = false;
+        this.pendingPreviewEvent = null;
+        this.removePlacementPreview();
+        this.updateMeasureRubberBand(null);
+        this.renderer.domElement.style.cursor = 'default';
+        this.lastMeasurement = {
+            points: this.measurePoints.map((point) => ({ x: point.x, y: point.y, z: point.z })),
+            distances: this.measureDistances(),
+            screenshot: this.captureMeasurementScreenshot(),
+        };
+        return this.lastMeasurement;
+    }
+    isMeasuring() {
+        return this.measuring;
+    }
+    /** The measurement finishMeasuring() last produced, for the form that saves it. */
+    getLastMeasurement() {
+        return this.lastMeasurement;
+    }
+    /** Metres between consecutive points. Tag space is in metres, so no conversion is involved. */
+    measureDistances() {
+        const distances = [];
+        for (let index = 1; index < this.measurePoints.length; index += 1) {
+            const distance = this.measurePoints[index - 1].distanceTo(this.measurePoints[index]);
+            // Two decimals, the precision Matterport's own measurements are stored with.
+            distances.push(Math.round(distance * 100) / 100);
+        }
+        return distances;
+    }
+    addMeasurePoint(point) {
+        const previous = this.measurePoints[this.measurePoints.length - 1];
+        this.measurePoints.push(point);
+        const marker = new THREE.Sprite(new THREE.SpriteMaterial({
+            map: this.createTagTexture(ThreeJsService.MEASURE_COLOR),
+            depthTest: false,
+            transparent: true,
+            // Sized against the viewport, not the model: measuring is done zoomed right in, where
+            // 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);
+        if (previous) {
+            this.measureGroup.add(this.createMeasureLine(previous, point));
+            const distance = Math.round(previous.distanceTo(point) * 100) / 100;
+            const label = new THREE.Sprite(new THREE.SpriteMaterial({
+                map: this.createMeasureLabelTexture(`${distance.toFixed(2)} m`),
                 depthTest: false,
                 transparent: true,
-                opacity: 0.6,
+                sizeAttenuation: false,
             }));
-            this.placementPreview.renderOrder = 999;
-            this.tagGroup.add(this.placementPreview);
-            this.scaleTagForModel(this.placementPreview);
-        }
-        this.placementPreview.position.copy(position);
+            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.measurementProgress$.next({
+            points: this.measurePoints.length,
+            distances: this.measureDistances(),
+        });
     }
     /**
-     * The point under the cursor, read from the depth buffer instead of raycast, in tag space.
-     *
-     * A raycast walks every triangle of the mesh it hits: on a captured model that is millions of
-     * them, tens of milliseconds, every time the pointer moves. Coalescing to one per frame did not
-     * help, because the cost is the pick itself - it simply became one slow frame instead of several.
-     *
-     * Rendering the model's depth into a single pixel under the cursor answers the same question on
-     * the GPU in constant time, whatever the model's size. The camera's view offset is what narrows
-     * the whole image down to that one pixel, so the value read back is the depth the cursor is over.
+     * A segment with a width in pixels.
      *
-     * Used for the ghost only. The click that actually places a tag still raycasts: it is one pick,
-     * its cost does not matter, and it yields the surface normal, which depth alone cannot give.
+     * 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.
      */
-    pickPointOnGpu(event) {
-        if (!this.modelRoot || !this.renderer || !this.camera) {
-            return null;
-        }
-        if (!this.pickTarget) {
-            this.pickTarget = new THREE.WebGLRenderTarget(1, 1);
-            this.pickCamera = new THREE.PerspectiveCamera();
+    createMeasureLine(from, to) {
+        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,
+            depthTest: false,
+            transparent: true,
+        });
+        const size = this.renderer.getSize(new THREE.Vector2());
+        material.resolution.set(size.x, size.y);
+        const line = new Line2(geometry, material);
+        line.renderOrder = 1000;
+        return line;
+    }
+    /** Line widths are in pixels, which the material can only honour if it knows the canvas size. */
+    updateMeasureLineResolution() {
+        if (!this.renderer) {
+            return;
+        }
+        const size = this.renderer.getSize(new THREE.Vector2());
+        this.measureGroup.children.forEach((child) => {
+            if (child.material?.resolution) {
+                child.material.resolution.set(size.x, size.y);
+            }
+        });
+    }
+    /** Stretches a segment from the last point to the pointer, or hides it when given null. */
+    updateMeasureRubberBand(target) {
+        const last = this.measurePoints[this.measurePoints.length - 1];
+        if (!this.measuring || !last || !target) {
+            if (this.measureRubberBand) {
+                this.measureRubberBand.visible = false;
+            }
+            return;
+        }
+        if (!this.measureRubberBand) {
+            this.measureRubberBand = this.createMeasureLine(last, target);
+            this.measureRubberBand.material.opacity = 0.6;
+            this.measureGroup.add(this.measureRubberBand);
+        }
+        this.measureRubberBand.geometry.setPositions([
+            last.x, last.y, last.z,
+            target.x, target.y, target.z,
+        ]);
+        this.measureRubberBand.visible = true;
+    }
+    createMeasureLabelTexture(text) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 384;
+        canvas.height = 128;
+        const context = canvas.getContext('2d');
+        const radius = 28;
+        context.fillStyle = 'rgba(0, 0, 0, 0.78)';
+        context.beginPath();
+        context.moveTo(radius, 8);
+        context.arcTo(canvas.width - 8, 8, canvas.width - 8, canvas.height - 8, radius);
+        context.arcTo(canvas.width - 8, canvas.height - 8, 8, canvas.height - 8, radius);
+        context.arcTo(8, canvas.height - 8, 8, 8, radius);
+        context.arcTo(8, 8, canvas.width - 8, 8, radius);
+        context.closePath();
+        context.fill();
+        context.fillStyle = '#FFFFFF';
+        context.font = 'bold 60px sans-serif';
+        context.textAlign = 'center';
+        context.textBaseline = 'middle';
+        context.fillText(text, canvas.width / 2, canvas.height / 2 + 4);
+        return new THREE.CanvasTexture(canvas);
+    }
+    /** Removes everything drawn for a measurement and forgets its points. */
+    clearMeasurement() {
+        [...this.measureGroup.children].forEach((child) => {
+            this.measureGroup.remove(child);
+            child.geometry?.dispose?.();
+            child.material?.map?.dispose?.();
+            child.material?.dispose?.();
+        });
+        this.measureRubberBand = undefined;
+        this.measurePoints = [];
+    }
+    /**
+     * A picture of the scene with the measurement on it, as Matterport attaches to its own.
+     *
+     * Tags are left out, as they are there: the picture is about the measurement. It is taken straight
+     * after a render because the drawing buffer is only guaranteed to hold the frame until the
+     * browser presents it, and scaled down since it is uploaded and shown as a thumbnail.
+     */
+    captureMeasurementScreenshot() {
+        const hidden = [];
+        this.tagSprites.forEach((sprite) => {
+            if (sprite.visible) {
+                sprite.visible = false;
+                hidden.push(sprite);
+            }
+        });
+        this.renderer.render(this.scene, this.camera);
+        const source = this.renderer.domElement;
+        const scale = Math.min(1, 800 / source.width, 600 / source.height);
+        const canvas = document.createElement('canvas');
+        canvas.width = Math.max(1, Math.round(source.width * scale));
+        canvas.height = Math.max(1, Math.round(source.height * scale));
+        canvas.getContext('2d').drawImage(source, 0, 0, canvas.width, canvas.height);
+        hidden.forEach((sprite) => {
+            sprite.visible = true;
+        });
+        return canvas.toDataURL('image/jpeg', 0.85);
+    }
+    /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
+    startTagPlacement(poiType = null) {
+        this.placingTag = true;
+        this.placementPoiType = poiType;
+        this.pendingTagPlacement = null;
+        if (this.renderer) {
+            this.renderer.domElement.style.cursor = 'crosshair';
+        }
+    }
+    /** Leaves placement mode without placing anything. */
+    cancelTagPlacement() {
+        this.placingTag = false;
+        this.pendingTagPlacement = null;
+        this.pendingPreviewEvent = null;
+        this.removePlacementPreview();
+        if (this.renderer) {
+            this.renderer.domElement.style.cursor = 'default';
+        }
+    }
+    /**
+     * Shows a translucent tag under the cursor while placing, so the spot is visible before commiting.
+     *
+     * Matterport does this with a tag that follows the pointer; the equivalent here is a preview
+     * sprite that gets removed the moment the real tag takes its place.
+     */
+    updatePlacementPreview(event) {
+        const position = this.pickPointOnGpu(event);
+        if (!position) {
+            this.removePlacementPreview();
+            this.updateMeasureRubberBand(null);
+            this.renderer.domElement.style.cursor = 'not-allowed';
+            return;
+        }
+        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,
+            }));
+            this.placementPreview.renderOrder = 999;
+            this.tagGroup.add(this.placementPreview);
+            this.scaleTagForModel(this.placementPreview);
+        }
+        this.placementPreview.position.copy(position);
+        this.updateMeasureRubberBand(position);
+    }
+    /**
+     * The point under the cursor, read from the depth buffer instead of raycast, in tag space.
+     *
+     * A raycast walks every triangle of the mesh it hits: on a captured model that is millions of
+     * them, tens of milliseconds, every time the pointer moves. Coalescing to one per frame did not
+     * help, because the cost is the pick itself - it simply became one slow frame instead of several.
+     *
+     * Rendering the model's depth into a single pixel under the cursor answers the same question on
+     * the GPU in constant time, whatever the model's size. The camera's view offset is what narrows
+     * the whole image down to that one pixel, so the value read back is the depth the cursor is over.
+     *
+     * Used for the ghost only. The click that actually places a tag still raycasts: it is one pick,
+     * its cost does not matter, and it yields the surface normal, which depth alone cannot give.
+     */
+    pickPointOnGpu(event) {
+        if (!this.modelRoot || !this.renderer || !this.camera) {
+            return null;
+        }
+        if (!this.pickTarget) {
+            this.pickTarget = new THREE.WebGLRenderTarget(1, 1);
+            this.pickCamera = new THREE.PerspectiveCamera();
             this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);
             this.pickDepthMaterial = new THREE.MeshDepthMaterial({
                 depthPacking: THREE.RGBADepthPacking,
@@ -6940,9 +8407,250 @@ class ThreeJsService {
      * filter that happens to match nothing.
      */
     setVisibleTagTypes(types) {
+        this.visibleTagTypes = types;
+        this.tagSprites.forEach((sprite) => this.applyTagVisibility(sprite));
+    }
+    /** Says which capture is on screen, so the tags placed in it can be told from the rest. */
+    setCurrentCapture(captureID) {
+        this.currentCaptureID = captureID;
         this.tagSprites.forEach((sprite) => {
-            sprite.visible = types === null || types.includes(sprite.userData.poiType);
+            this.parentTag(sprite);
+            this.applyTagVisibility(sprite);
+        });
+    }
+    /** Every tag registered in the scene, shown or not. */
+    getTags() {
+        const candidates = new Set(this.calibrationCandidates());
+        return [...this.tagSprites.values()].map((sprite) => ({
+            id: sprite.name,
+            label: sprite.userData.label ?? null,
+            poiType: sprite.userData.poiType ?? null,
+            visible: sprite.visible,
+            calibratable: candidates.has(sprite),
+        }));
+    }
+    /**
+     * How far the tags from elsewhere sit from the model, measured in model radii. Null without both.
+     *
+     * Before a model is calibrated those tags are wherever their own coordinates put them, which for
+     * a model with a different origin can be a long way off - too far to find, let alone click.
+     */
+    getTagDistanceFromModel() {
+        if (!this.modelRoot || !this.modelWorldRadius) {
+            return null;
+        }
+        const centroid = new THREE.Vector3();
+        const candidates = this.calibrationCandidates();
+        candidates.forEach((sprite) => centroid.add(sprite.getWorldPosition(new THREE.Vector3())));
+        const count = candidates.length;
+        if (count === 0) {
+            return null;
+        }
+        // The model is centred on the world origin when it is placed.
+        return centroid.divideScalar(count).length() / this.modelWorldRadius;
+    }
+    /**
+     * Hangs a tag from the group its coordinates belong to: outside the calibration when they are in
+     * this model's own coordinates, under it otherwise.
+     */
+    parentTag(sprite) {
+        const parent = sprite.userData.frame === 'model' && this.isOwnedByVisit(sprite)
+            ? this.modelTagGroup
+            : this.tagGroup;
+        if (sprite.parent !== parent) {
+            parent.add(sprite);
+        }
+    }
+    /**
+     * The tags a calibration can be worked out from: those that came from somewhere else, whether or
+     * not they are on show - before calibrating, most of them will not be.
+     *
+     * Tags placed in this model are where they are because someone clicked there; matching them to
+     * "where they really are" would be circular. A tag in another model's own coordinates cannot be
+     * placed here at all. And a tag already used in this calibration cannot be used again - two
+     * pairs from one tag carry no more than one.
+     */
+    calibrationCandidates() {
+        const used = new Set(this.alignmentPairs.map((pair) => pair.tagId));
+        return [...this.tagSprites.values()].filter((sprite) => sprite.parent === this.tagGroup
+            && sprite.userData.frame !== 'model'
+            && !this.isOwnedByVisit(sprite)
+            && !used.has(sprite.name));
+    }
+    /** How many tags there are to calibrate with, not counting those already used. */
+    getCalibrationCandidateCount() {
+        return this.calibrationCandidates().length;
+    }
+    /**
+     * How many tags from elsewhere are not on this model, and so not shown on it.
+     *
+     * On a model that has not been calibrated, this is what suggests it should be: the tags are out
+     * there, just not where the model is.
+     */
+    getOffModelTagCount() {
+        return this.calibrationCandidates().filter((sprite) => !this.isOnModel(sprite)).length;
+    }
+    /** Whether the tag was placed in the visit on screen. */
+    isOwnedByVisit(sprite) {
+        return !!sprite.userData.originCaptureID
+            && sprite.userData.originCaptureID === this.currentCaptureID;
+    }
+    /**
+     * A tag shows when its type is not filtered out and it belongs on this model.
+     *
+     * One place decides, because the two used to set `visible` separately and whichever ran last
+     * undid the other.
+     */
+    applyTagVisibility(sprite) {
+        const typeAllowed = this.visibleTagTypes === null
+            || this.visibleTagTypes.includes(sprite.userData.poiType);
+        sprite.visible = typeAllowed && this.belongsOnThisModel(sprite);
+    }
+    /**
+     * Whether a tag has a place on this model.
+     *
+     * Every tag of the space is offered to every model - there is one set of tags, not one per model.
+     * What a model shows of it is the part that sits on the model.
+     */
+    belongsOnThisModel(sprite) {
+        // Placed here by a click on this very surface.
+        if (this.isOwnedByVisit(sprite)) {
+            return true;
+        }
+        // Placed in another model before that one was calibrated: its coordinates are that model's own
+        // and say nothing about where it would be in this one.
+        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) {
+            return true;
+        }
+        return this.isOnModel(sprite);
+    }
+    /** Whether a tag, drawn where its coordinates and the calibration put it, sits on the model. */
+    isOnModel(sprite) {
+        if (!this.surfaceCells) {
+            // No model to be on yet.
+            return false;
+        }
+        const parent = sprite.parent ?? this.tagGroup;
+        parent.updateMatrix();
+        // The grid is in the model's own units; the calibration's scale is how many of those a metre is.
+        const reach = ThreeJsService.ON_MODEL_METRES * (parent.scale.x || 1);
+        return this.isNearSurface(sprite.position.clone().applyMatrix4(parent.matrix), reach);
+    }
+    /** Re-decides every tag's visibility: the model, the calibration or the mode changed. */
+    refreshTagVisibility() {
+        this.tagSprites.forEach((sprite) => this.applyTagVisibility(sprite));
+    }
+    surfaceKey(x, y, z) {
+        const span = ThreeJsService.SURFACE_GRID_SPAN;
+        const pad = ThreeJsService.SURFACE_GRID_PAD;
+        const [i, j, k] = [x + pad, y + pad, z + pad];
+        if (i < 0 || j < 0 || k < 0 || i >= span || j >= span || k >= span) {
+            return -1;
+        }
+        return i + span * (j + span * k);
+    }
+    /**
+     * Lays the grid over the model's surface.
+     *
+     * Runs once per model, in one pass over its triangles. A triangle smaller than a cell is marked
+     * by its centre, which is every triangle of a scanned model; a larger one - the two triangles of
+     * a drawn wall - is sampled across its face, or the middle of the wall would read as empty.
+     */
+    buildSurfaceGrid(object, box) {
+        const size = box.getSize(new THREE.Vector3());
+        const longest = Math.max(size.x, size.y, size.z);
+        if (!(longest > 0)) {
+            this.surfaceCells = null;
+            return;
+        }
+        // A quarter of a metre where the model is in metres; coarser on a very large one, so the grid
+        // stays addressable and its memory bounded.
+        const cell = Math.max(0.25, longest / 384);
+        const origin = box.min.clone();
+        const cells = new Set();
+        const mark = (point) => {
+            const key = this.surfaceKey(Math.floor((point.x - origin.x) / cell), Math.floor((point.y - origin.y) / cell), Math.floor((point.z - origin.z) / cell));
+            if (key >= 0) {
+                cells.add(key);
+            }
+        };
+        let triangleCount = 0;
+        object.updateMatrixWorld(true);
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (position) {
+                triangleCount += (child.geometry.index ? child.geometry.index.count : position.count) / 3;
+            }
+        });
+        // Past a few million triangles they are far smaller than a cell, and every cell is hit many
+        // times over; a sample marks the same cells.
+        const stride = Math.max(1, Math.ceil(triangleCount / 3000000));
+        const a = new THREE.Vector3();
+        const b = new THREE.Vector3();
+        const c = new THREE.Vector3();
+        const point = new THREE.Vector3();
+        object.traverse((child) => {
+            const position = child.isMesh && child.geometry?.attributes?.position;
+            if (!position) {
+                return;
+            }
+            const index = child.geometry.index;
+            const count = (index ? index.count : position.count) / 3;
+            for (let triangle = 0; triangle < count; triangle += stride) {
+                const offset = triangle * 3;
+                a.fromBufferAttribute(position, index ? index.getX(offset) : offset).applyMatrix4(child.matrixWorld);
+                b.fromBufferAttribute(position, index ? index.getX(offset + 1) : offset + 1).applyMatrix4(child.matrixWorld);
+                c.fromBufferAttribute(position, index ? index.getX(offset + 2) : offset + 2).applyMatrix4(child.matrixWorld);
+                const edge = Math.max(a.distanceTo(b), b.distanceTo(c), c.distanceTo(a));
+                if (edge <= cell) {
+                    mark(point.copy(a).add(b).add(c).multiplyScalar(1 / 3));
+                    continue;
+                }
+                // Half-cell steps across the face. Capped, so one enormous triangle cannot stall the load;
+                // the reach a tag is tested with spans several cells and bridges what the cap leaves.
+                const steps = Math.min(96, Math.ceil((2 * edge) / cell));
+                for (let i = 0; i <= steps; i += 1) {
+                    for (let j = 0; j <= steps - i; j += 1) {
+                        point.copy(a)
+                            .addScaledVector(b.clone().sub(a), i / steps)
+                            .addScaledVector(c.clone().sub(a), j / steps);
+                        mark(point);
+                    }
+                }
+            }
         });
+        this.surfaceCells = cells;
+        this.surfaceOrigin.copy(origin);
+        this.surfaceCellSize = cell;
+    }
+    /** Whether some part of the model's surface lies within `reach` of a point, in model units. */
+    isNearSurface(point, reach) {
+        const cell = this.surfaceCellSize;
+        const origin = this.surfaceOrigin;
+        const x = (point.x - origin.x) / cell;
+        const y = (point.y - origin.y) / cell;
+        const z = (point.z - origin.z) / cell;
+        // In cells. Capped: beyond this the calibration's scale makes a metre so many cells that the
+        // search would dwarf the model, and a tag that far off is not on it by any reading.
+        const span = Math.min(16, Math.ceil(reach / cell));
+        // A cell is "within reach" when its centre is, give or take the half-diagonal of the cell.
+        const limit = (reach / cell + 0.87) ** 2;
+        const [cx, cy, cz] = [Math.floor(x), Math.floor(y), Math.floor(z)];
+        for (let k = cz - span; k <= cz + span; k += 1) {
+            for (let j = cy - span; j <= cy + span; j += 1) {
+                for (let i = cx - span; i <= cx + span; i += 1) {
+                    const distance = (i + 0.5 - x) ** 2 + (j + 0.5 - y) ** 2 + (k + 0.5 - z) ** 2;
+                    if (distance <= limit && this.surfaceCells.has(this.surfaceKey(i, j, k))) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
     }
     /**
      * Moves the camera to look at a tag, mirroring Matterport's goToTag.
@@ -7073,8 +8781,11 @@ class ThreeJsService {
         this.tagGroup.position.set(translation?.x ?? 0, translation?.y ?? 0, translation?.z ?? 0);
         this.tagGroup.rotation.set(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);
         this.tagGroup.scale.setScalar(scale ?? 1);
-        // Tag size is derived from the world scale it inherits, which this call just changed.
+        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));
+        this.refreshTagVisibility();
     }
     /**
      * Adds a tag, or moves/restyles the one already registered for this element.
@@ -7089,6 +8800,10 @@ class ThreeJsService {
             existing.position.set(tag.position.x, tag.position.y, tag.position.z);
             existing.userData.poiType = tag.poiType ?? existing.userData.poiType;
             existing.userData.label = tag.label ?? existing.userData.label;
+            existing.userData.originCaptureID = tag.originCaptureID ?? existing.userData.originCaptureID;
+            existing.userData.frame = tag.frame ?? existing.userData.frame;
+            this.parentTag(existing);
+            this.applyTagVisibility(existing);
             return;
         }
         const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
@@ -7101,10 +8816,13 @@ class ThreeJsService {
         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.position.set(tag.position.x, tag.position.y, tag.position.z);
         sprite.renderOrder = 999;
+        this.parentTag(sprite);
         this.scaleTagForModel(sprite);
-        this.tagGroup.add(sprite);
+        this.applyTagVisibility(sprite);
         this.tagSprites.set(tag.id, sprite);
         if (tag.iconUrl) {
             this.applyTagIcon(sprite, tag.iconUrl);
@@ -7116,7 +8834,7 @@ class ThreeJsService {
         if (!sprite) {
             return;
         }
-        this.tagGroup.remove(sprite);
+        sprite.parent?.remove(sprite);
         sprite.material.map?.dispose();
         sprite.material.dispose();
         this.tagSprites.delete(elementId);
@@ -7157,7 +8875,8 @@ class ThreeJsService {
      * size on screen whatever the model's units are.
      */
     scaleTagForModel(sprite) {
-        const worldScale = this.tagGroup.getWorldScale(new THREE.Vector3()).x || 1;
+        // 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);
     }
@@ -7216,7 +8935,7 @@ class ThreeJsService {
             this.removePlacementPreview();
             // Tags first: they draw on top of the model, so they have to answer the pointer first too.
             const hoveredTag = this.raycaster
-                .intersectObjects(this.tagGroup.children, false)
+                .intersectObjects([...this.tagSprites.values()], false)
                 .find((hit) => hit.object.visible)?.object;
             if (hoveredTag) {
                 this.renderer.domElement.style.cursor = 'pointer';
@@ -7244,110 +8963,589 @@ class ThreeJsService {
             this.objectHovered$.next(null);
         }
     }
-    onMouseClick(event) {
-        if (!this.isDraggingCamera) {
-            const rect = this.renderer.domElement.getBoundingClientRect();
-            this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
-            this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
-            // Alignment and placement both take the click before anything can be opened by it.
-            if (this.aligning) {
-                this.raycaster.setFromCamera(this.mouse, this.camera);
-                this.handleAlignmentClick(event);
-                return;
-            }
-            // Placement wins over everything: while armed, a click means "put it here", not "open that".
-            if (this.placingTag) {
-                const placement = this.pickPlacementOnModel(event);
-                if (placement) {
-                    placement.poiType = this.placementPoiType;
-                    this.pendingTagPlacement = placement;
-                    this.placingTag = false;
-                    this.removePlacementPreview();
-                    this.renderer.domElement.style.cursor = 'default';
-                    this.tagPlaced$.next(placement);
-                }
-                return;
-            }
-            this.raycaster.setFromCamera(this.mouse, this.camera);
-            // Same precedence as hover: a tag drawn over the model claims the click.
-            const tagHits = this.raycaster.intersectObjects(this.tagGroup.children, false)
-                .filter((hit) => hit.object.visible);
-            if (tagHits.length > 0) {
-                const tag = tagHits[0].object;
-                this.tagClicked$.next({ elementId: tag.name, poiType: tag.userData.poiType ?? null });
-                return;
-            }
-            const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);
-            if (intersects.length > 0) {
-                const clickedObject = intersects[0].object;
-                const id = clickedObject?.parent?.name;
-                if (id) {
-                    this.objectClicked$.next(id);
-                }
-            }
-            else {
-                this.objectClicked$.next(null);
+    onMouseClick(event) {
+        if (!this.isDraggingCamera) {
+            const rect = this.renderer.domElement.getBoundingClientRect();
+            this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+            this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+            // Alignment and placement both take the click before anything can be opened by it.
+            if (this.aligning) {
+                this.raycaster.setFromCamera(this.mouse, this.camera);
+                this.handleAlignmentClick(event);
+                return;
+            }
+            // Measuring takes every click as a point, the same way placement takes it as a position.
+            if (this.measuring) {
+                const placement = this.pickPlacementOnModel(event);
+                if (placement) {
+                    const { x, y, z } = placement.position;
+                    this.addMeasurePoint(new THREE.Vector3(x, y, z));
+                }
+                return;
+            }
+            // Placement wins over everything: while armed, a click means "put it here", not "open that".
+            if (this.placingTag) {
+                const placement = this.pickPlacementOnModel(event);
+                if (placement) {
+                    placement.poiType = this.placementPoiType;
+                    this.pendingTagPlacement = placement;
+                    this.placingTag = false;
+                    this.removePlacementPreview();
+                    this.renderer.domElement.style.cursor = 'default';
+                    this.tagPlaced$.next(placement);
+                }
+                return;
+            }
+            this.raycaster.setFromCamera(this.mouse, this.camera);
+            // Same precedence as hover: a tag drawn over the model claims the click.
+            const tagHits = this.raycaster.intersectObjects([...this.tagSprites.values()], false)
+                .filter((hit) => hit.object.visible);
+            if (tagHits.length > 0) {
+                const tag = tagHits[0].object;
+                this.tagClicked$.next({ elementId: tag.name, poiType: tag.userData.poiType ?? null });
+                return;
+            }
+            const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);
+            if (intersects.length > 0) {
+                const clickedObject = intersects[0].object;
+                const id = clickedObject?.parent?.name;
+                if (id) {
+                    this.objectClicked$.next(id);
+                }
+            }
+            else {
+                this.objectClicked$.next(null);
+            }
+        }
+    }
+    /**
+     * Escape cancels whatever the pointer is currently committed to.
+     *
+     * 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 (event.key !== 'Escape') {
+            return;
+        }
+        if (this.placingTag) {
+            // Nothing outside the scene tracks placement, so clearing it here is the whole of it.
+            this.cancelTagPlacement();
+            return;
+        }
+        if (this.measuring) {
+            this.cancelMeasuring();
+            return;
+        }
+        if (this.aligning) {
+            this.cancelTagAlignment();
+        }
+    };
+    animate = () => {
+        this.animationFrameId = requestAnimationFrame(this.animate);
+        this.stepCameraTween();
+        this.controls.update();
+        // One pick per frame, against the pointer's latest position - see onMouseMove.
+        if (this.pendingPreviewEvent) {
+            const event = this.pendingPreviewEvent;
+            this.pendingPreviewEvent = null;
+            this.updatePlacementPreview(event);
+        }
+        this.renderer.render(this.scene, this.camera);
+    };
+    destroy() {
+        if (this.animationFrameId) {
+            cancelAnimationFrame(this.animationFrameId);
+        }
+        window.removeEventListener('keydown', this.onKeyDown);
+        if (this.canvasResizeObserver) {
+            this.canvasResizeObserver.disconnect();
+            this.canvasResizeObserver = undefined;
+        }
+        this.discardCurrentLoad();
+        this.clearTags();
+        this.measuring = false;
+        this.clearMeasurement();
+        if (this.renderer) {
+            this.renderer.dispose();
+        }
+        if (this.controls) {
+            this.controls.dispose();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i0.NgZone }] });
+
+class CaptureService {
+    API; //AWS
+    constructor(apiInjected) {
+        this.API = apiInjected;
+    }
+    async getCapturesBySpace(spaceID) {
+        return this.API.CapturesBySpace(spaceID).then((cap) => cap.items);
+    }
+    async getCapture(captureID) {
+        return this.API.__proto__.GetCapture(captureID);
+    }
+    async deleteCapture(captureID) {
+        return this.API.__proto__.DeleteCapture({ id: captureID });
+    }
+    async updateCapture(capture) {
+        return this.API.__proto__.UpdateCapture(capture);
+    }
+    async createCapture(capture) {
+        return this.API.__proto__.CreateCapture(capture);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaptureService, deps: [{ token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaptureService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaptureService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['currentAPIService']
+                }] }] });
+
+/* eslint-disable class-methods-use-this */
+class ZoneService {
+    userService;
+    API; //AWS APIService
+    constructor(apiInjected, userService) {
+        this.userService = userService;
+        this.API = apiInjected;
+    }
+    async getZonesBySpace(spaceID) {
+        const list = [];
+        if (this.API.__proto__.hasOwnProperty('ZonesBySpace')) {
+            // Paginated: without a nextToken loop, only the first page (100 zones) was returned and
+            // the sweeps of the other zones silently disappeared.
+            let nextToken = null;
+            do {
+                const zones = await this.API.__proto__.ZonesBySpace(spaceID, null, null, 1000, nextToken);
+                for (const zone of zones?.items || []) {
+                    const zoneObject = { ...zone };
+                    zoneObject.virtual = this.zoneIsVirtual(zone);
+                    list.push(zoneObject);
+                }
+                nextToken = zones?.nextToken ?? null;
+            } while (nextToken);
+            return list;
+        }
+        else {
+            throw new Error('ZonesBySpace not implemented');
+        }
+    }
+    async getZonesBySpaceForUser(spaceID) {
+        const missionForLocation = this.userService.currentMission(spaceID);
+        const list = [];
+        if (missionForLocation && missionForLocation.zoneID) {
+            const allowedZone = await this.getZone(missionForLocation.zoneID);
+            allowedZone.virtual = this.zoneIsVirtual(allowedZone);
+            if (!allowedZone.parent) {
+                // the whole building is authorized
+                return this.getZonesBySpace(spaceID);
+            }
+            list.push(allowedZone);
+            // allow all children zones of an allowed parent
+            const children = (await this.API.__proto__.ZonesByZone(allowedZone.id))
+                .items;
+            if (children.length > 0) {
+                for (const child of children) {
+                    const childZone = { ...child };
+                    childZone.virtual = this.zoneIsVirtual(child);
+                    list.push(childZone);
+                }
+            }
+            // allow the parent Floor of the allowed zone
+            if (allowedZone.parent.layer &&
+                allowedZone.parent.layer.name === 'FLOOR') {
+                list.push(allowedZone.parent);
+            }
+        }
+        else {
+            return this.getZonesBySpace(spaceID);
+        }
+        return list;
+    }
+    async filterZonesIDsForUser(zones) {
+        const { spaceID } = zones[0];
+        const zoneIDs = new Set(zones.map((zone) => zone.id));
+        const allowedZones = await this.getZonesBySpaceForUser(spaceID);
+        const filteredZones = allowedZones.filter((zone) => zoneIDs.has(zone.id));
+        return filteredZones;
+    }
+    async deleteZone(zoneID) {
+        return this.API.__proto__.DeleteZone({ id: zoneID });
+    }
+    async getZonesForSweepForSpace(sweepID, spaceID) {
+        const zonesSpace = (await this.API.__proto__.ZonesBySpace(spaceID)).items;
+        return zonesSpace.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(sweepID));
+    }
+    // // eslint-disable-next-line class-methods-use-this
+    sortZonesFromChildToParent(zonesToSort) {
+        // get default
+        const defaultZone = zonesToSort.find((z) => !z.parentID);
+        if (defaultZone) {
+            const indexOf = zonesToSort.indexOf(defaultZone);
+            zonesToSort.splice(indexOf, 1);
+        }
+        const zones = zonesToSort.sort((a, b) => {
+            if (a.parentID === b.id) {
+                return -1;
+            }
+            return 0;
+        });
+        // so far by number of navigation points in them
+        // const zones = zonesToSort.sort(
+        //     (a, b) => a.navigations.items.length - b.navigations.items.length,
+        // );
+        if (defaultZone) {
+            zones.push(defaultZone);
+        }
+        return zones;
+    }
+    async getZonesForObject(object) {
+        if (object.pois.items && object.pois.items.length > 0) {
+            const [poi] = object.pois.items;
+            if (poi.matterportSweepID) {
+                const zones = await this.getZonesForSweepForSpace(poi.matterportSweepID, object.spaceID);
+                return zones;
+            }
+        }
+        return null;
+    }
+    async createVirtualZone(zoneInput) {
+        zoneInput.sweepIDs = [];
+        const zone = await this.API.__proto__.CreateZone(zoneInput);
+        console.log('virtual zone created', zone);
+        return zone;
+    }
+    zoneIsVirtual(zone) {
+        if (!zone.sweepIDs) {
+            return true;
+        }
+        if ((zone.tags && zone.tags.includes('virtual')) ||
+            zone.sweepIDs.length === 0) {
+            return true;
+        }
+        return false;
+    }
+    async getModel3DForZone(zoneID) {
+        const zone = await this.API.__proto__.GetZone(zoneID);
+        if (zone.nodeIDs) {
+            const node = await this.API.__proto__.GetNode(zone.nodeIDs[0]);
+            return node.model3D;
+        }
+        return null;
+    }
+    async getZone(zoneID) {
+        return this.API.__proto__.GetZone(zoneID);
+    }
+    async getDefaultZoneForSpace(spaceID) {
+        return this.getZonesBySpace(spaceID).then(async (zones) => {
+            const zonesBuilding = zones.filter((zone) => zone.layer && zone.layer.name === 'BUILDING');
+            if (zonesBuilding.length === 1) {
+                return zonesBuilding[0];
+            }
+            const parentZone = zones.find((zone) => !zone.parentID);
+            return parentZone;
+        });
+    }
+    async create(input) {
+        return this.API.__proto__.CreateZone(input);
+    }
+    // async getSortedZonesForSweepForUser(
+    //     sweep: string,
+    //     spaceID: string,
+    // ): Promise<Zone[]> {
+    //     if (!spaceID) {
+    //         return [];
+    //     }
+    //     const zones = await this.getZonesForSweepForSpace(sweep, spaceID);
+    //     if (zones.length === 0) {
+    //         return [];
+    //     }
+    //     const filteredZones = await this.filterZonesIDsForUser(zones);
+    //     if (filteredZones.length > 0) {
+    //         let zonesSorted = this.sortZonesFromChildToParent(filteredZones);
+    //         zonesSorted = zonesSorted.filter((zone) => zone !== undefined);
+    //         return zonesSorted;
+    //     }
+    //     return [];
+    // }
+    async updateZone(input) {
+        return this.API.__proto__.UpdateZone(input);
+    }
+    async getZonesForNodeForSpace(nodeID, spaceID) {
+        return this.API.__proto__.ZonesBySpace(spaceID).then(async (zones) => {
+            const filteredZones = zones.items.filter((zone) => zone.nodeIDs && zone.nodeIDs.includes(nodeID));
+            return filteredZones;
+        });
+    }
+    /**
+     * Gets the Zone (layer FLOOR) for a matterport sweep ID in a given Space
+     * @param sweepID
+     * @param spaceID
+     * @returns Zone
+     */
+    async getFloorZoneForSweepInSpace(sweepID, spaceID) {
+        const zones = await this.getZonesForSweepForSpace(sweepID, spaceID);
+        const floors = zones.filter((zone) => zone.layer && zone.layer.name.includes('FLOOR'));
+        return floors.length > 0 ? floors[0] : null;
+    }
+    /**
+     * Get zones with audio track for entire space
+     * @param spaceID
+     * @returns  Promise<Zone[]>
+     */
+    async getAudioZonesForSpace(spaceID) {
+        const allZones = await this.getZonesBySpace(spaceID);
+        return allZones.filter((zone) => zone.audioID);
+    }
+    /**
+     * Get audio zones for user (within allowed zones)
+     * @param spaceID
+     * @returns  Promise<Zone[]>
+     */
+    async getAudioZonesForUserForSpace(spaceID) {
+        const userZones = await this.getZonesBySpaceForUser(spaceID);
+        return userZones.filter((zone) => zone.audioID);
+    }
+    /**
+     * Get Zones by Parent Zone ID
+     * @param parentZoneID string
+     * @returns Promise<Zone[]>
+     */
+    async getZonesByParentZone(parentZoneID) {
+        return this.API.__proto__
+            .ZonesByZone(parentZoneID)
+            .then((res) => res.items);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ZoneService, deps: [{ token: 'currentAPIService' }, { token: BaseUserService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ZoneService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ZoneService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['currentAPIService']
+                }] }, { type: BaseUserService }] });
+
+class NavigationService {
+    userService;
+    zoneService;
+    API;
+    constructor(apiInjected, userService, zoneService) {
+        this.userService = userService;
+        this.zoneService = zoneService;
+        this.API = apiInjected;
+    }
+    async createNavigation(navInput) {
+        return this.API.__proto__.CreateNavigation(navInput);
+    }
+    async deleteNavigation(id) {
+        return this.API.__proto__.DeleteNavigation({ id });
+    }
+    async getNavigationsForNode(nodeID) {
+        const limit = 200;
+        let navigationsTokenDict = { navigations: [], nextToken: null };
+        do {
+            navigationsTokenDict =
+                await this.mergeAPIResponseWithNextTokenWithLimit(nodeID, limit, navigationsTokenDict);
+        } while (navigationsTokenDict.nextToken);
+        return navigationsTokenDict.navigations;
+    }
+    async mergeAPIResponseWithNextTokenWithLimit(nodeID, limit, navigationsTokenDict) {
+        return this.API.__proto__.NavigationsByNode(nodeID, null, null, limit, navigationsTokenDict.nextToken).then((response) => {
+            const navigations = response.items;
+            const navObject = {
+                navigations: [...navigationsTokenDict.navigations, ...navigations],
+                nextToken: response.nextToken,
+            };
+            return navObject;
+        });
+    }
+    async getNavigation(id) {
+        return this.API.__proto__.GetNavigation(id);
+    }
+    async getSweepsIDsForSpace(spaceID) {
+        const zones = await this.zoneService.getZonesBySpace(spaceID);
+        const zonesWithSweeps = zones.filter((zone) => zone.sweepIDs && zone.sweepIDs.length > 0);
+        const allSweeps = zonesWithSweeps.flatMap((zone) => zone.sweepIDs);
+        return [...new Set(allSweeps)];
+    }
+    async getAllowedSweepsIDsForUserInSpace(spaceID) {
+        const missionsForSpace = this.userService.currentMissions.filter((mis) => mis.spaceID === spaceID);
+        console.log(missionsForSpace);
+        let navIDs = [];
+        if (this.userService.userHasAccessToAllZonesInSpace(spaceID)) {
+            console.log(1);
+            return this.getSweepsIDsForSpace(spaceID);
+        }
+        await Promise.all(missionsForSpace.map(async (mission) => {
+            navIDs = [...navIDs, ...mission.zone.sweepIDs];
+        }));
+        console.log('final navids = ', navIDs);
+        return navIDs;
+    }
+    async getForbiddenNavigationIDsForUserInSpace(spaceID) {
+        const allowed = await this.getAllowedSweepsIDsForUserInSpace(spaceID);
+        const allNavs = await this.getSweepsIDsForSpace(spaceID);
+        const difference = allNavs.filter((x) => !allowed.includes(x));
+        return difference.length > 0 ? difference : null;
+    }
+    async getNavigationsForMatterportIDForSpace(matterportID, spaceID) {
+        return this.API.__proto__.NavigationsByMatterportIDBySpace(matterportID, {
+            eq: spaceID,
+        }).then((navs) => navs.items);
+    }
+    async getNavigationsForZone(zone) {
+        const responseNavs = [];
+        await Promise.all(zone.sweepIDs.map(async (sweepID) => {
+            const navs = await this.getNavigationsForMatterportIDForSpace(sweepID, zone.spaceID);
+            if (navs.length > 0) {
+                responseNavs.push(navs[0]);
             }
-        }
+        }));
+        return responseNavs;
+    }
+    async updateNavigation(navInput) {
+        return this.API.__proto__.UpdateNavigation(navInput);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, deps: [{ token: 'currentAPIService' }, { token: BaseUserService }, { token: ZoneService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['currentAPIService']
+                }] }, { type: BaseUserService }, { type: ZoneService }] });
+
+/**
+ * Finds the Matterport sweep a point in a space sits closest to.
+ *
+ * A tag placed in Matterport is recorded with the sweep it was placed from, and much of the
+ * Matterport side keys on that: which floor plan draws the tag, which zone it belongs to, which
+ * floor it shows on. A tag placed in the Three.js viewer has no sweep, so it was missing from all
+ * of them. Resolving the nearest one at creation - what the tag copy tool already does for copied
+ * tags - lets every one of those readers work unchanged instead of each growing its own exception.
+ */
+class SweepLocatorService {
+    captureService;
+    navigationService;
+    /**
+     * Sweeps sit a few metres apart, so a point on a scanned surface always has one nearby. Anything
+     * further means the coordinates are not in the Matterport capture's space - a model that was
+     * never calibrated - and a sweep picked from that far would file the tag under an arbitrary
+     * floor. Leaving it without one is the honest answer there.
+     */
+    static MAX_DISTANCE_METRES = 10;
+    /** Sweep positions per space. They only change on import, so one load per session is enough. */
+    sweepsBySpace = new Map();
+    constructor(captureService, navigationService) {
+        this.captureService = captureService;
+        this.navigationService = navigationService;
     }
     /**
-     * Escape cancels whatever the pointer is currently committed to.
+     * The sweep nearest to a point, or null when the space has none within reach.
      *
-     * 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.
+     * Never throws: this only refines where a tag is filed, and a tag that cannot be filed is still
+     * better saved without a sweep than not saved at all.
      */
-    onKeyDown = (event) => {
-        if (event.key !== 'Escape') {
-            return;
-        }
-        if (this.placingTag) {
-            // Nothing outside the scene tracks placement, so clearing it here is the whole of it.
-            this.cancelTagPlacement();
-            return;
-        }
-        if (this.aligning) {
-            this.cancelTagAlignment();
+    async findNearestSweep(point, spaceID) {
+        if (!point || !spaceID) {
+            return null;
         }
-    };
-    animate = () => {
-        this.animationFrameId = requestAnimationFrame(this.animate);
-        this.stepCameraTween();
-        this.controls.update();
-        // One pick per frame, against the pointer's latest position - see onMouseMove.
-        if (this.pendingPreviewEvent) {
-            const event = this.pendingPreviewEvent;
-            this.pendingPreviewEvent = null;
-            this.updatePlacementPreview(event);
+        try {
+            return this.nearestSweep(point, await this.loadSweeps(spaceID));
         }
-        this.renderer.render(this.scene, this.camera);
-    };
-    destroy() {
-        if (this.animationFrameId) {
-            cancelAnimationFrame(this.animationFrameId);
+        catch (error) {
+            console.warn(`SweepLocatorService: could not resolve a sweep in space ${spaceID}`, error);
+            return null;
         }
-        window.removeEventListener('keydown', this.onKeyDown);
-        if (this.canvasResizeObserver) {
-            this.canvasResizeObserver.disconnect();
-            this.canvasResizeObserver = undefined;
+    }
+    /** The sweep closest to a point, or null when none is within reach. */
+    nearestSweep(point, sweeps) {
+        let nearest = null;
+        let nearestDistance = SweepLocatorService.MAX_DISTANCE_METRES;
+        for (const sweep of sweeps) {
+            const distance = Math.hypot(sweep.x - point.x, sweep.y - point.y, sweep.z - point.z);
+            if (distance <= nearestDistance) {
+                nearestDistance = distance;
+                nearest = sweep.sweepID;
+            }
         }
-        this.discardCurrentLoad();
-        this.clearTags();
-        if (this.renderer) {
-            this.renderer.dispose();
+        return nearest;
+    }
+    loadSweeps(spaceID) {
+        let sweeps = this.sweepsBySpace.get(spaceID);
+        if (!sweeps) {
+            sweeps = this.fetchSweeps(spaceID);
+            this.sweepsBySpace.set(spaceID, sweeps);
+            // A failed load must not be remembered as "this space has no sweeps".
+            sweeps.catch(() => this.sweepsBySpace.delete(spaceID));
         }
-        if (this.controls) {
-            this.controls.dispose();
+        return sweeps;
+    }
+    async fetchSweeps(spaceID) {
+        const captures = await this.captureService.getCapturesBySpace(spaceID);
+        // A 3D model is imported with one navigation entry of its own, a placeholder sitting at the
+        // origin. It is not a sweep, and counting it would make it the "nearest" for any tag close to
+        // the origin.
+        const nodeIDs = (captures ?? [])
+            .filter((capture) => capture.viewer !== CaptureViewer.THREEJS)
+            .reduce((all, capture) => all.concat(capture.nodes?.items ?? []), [])
+            .map((node) => node?.id)
+            .filter((id) => !!id);
+        const navigations = (await Promise.all(nodeIDs.map((id) => this.navigationService.getNavigationsForNode(id)))).reduce((all, list) => all.concat(list), []);
+        const sweeps = [];
+        for (const navigation of navigations) {
+            if (!navigation?.matterportSweepID || !navigation.position) {
+                continue;
+            }
+            try {
+                const position = JSON.parse(navigation.position);
+                if ([position?.x, position?.y, position?.z].every((value) => typeof value === 'number')) {
+                    sweeps.push({
+                        sweepID: navigation.matterportSweepID,
+                        x: position.x,
+                        y: position.y,
+                        z: position.z,
+                    });
+                }
+            }
+            catch {
+                // One unreadable position should not cost the space all of its sweeps.
+            }
         }
+        return sweeps;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SweepLocatorService, deps: [{ token: CaptureService }, { token: NavigationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SweepLocatorService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThreeJsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SweepLocatorService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: i0.NgZone }] });
+        }], ctorParameters: () => [{ type: CaptureService }, { type: NavigationService }] });
 
 /* eslint-disable no-await-in-loop */
 /* eslint-disable camelcase */
@@ -7359,6 +9557,7 @@ class ViewerService {
     poiService;
     matterportService;
     threeJsService;
+    sweepLocator;
     viewerMode = 'Matterport';
     currentModel3D;
     tourUrl;
@@ -7374,6 +9573,20 @@ class ViewerService {
      * lists that feed tags are exactly that.
      */
     currentSpaceID = null;
+    /**
+     * The Three.js capture on screen, or null in Matterport.
+     *
+     * A space can hold several 3D models. A tag placed in one is recorded with it, so that model
+     * keeps showing the tag whatever selection of tags it is otherwise restricted to.
+     */
+    currentCaptureID = null;
+    /**
+     * Whether the 3D model on screen has been calibrated against the tags' shared space.
+     *
+     * Calibrating is what says the model and that space overlap. Until then a tag placed in the model
+     * is in the model's own coordinates: it belongs to no Matterport sweep and to no other visit.
+     */
+    threeJsCalibrated = false;
     sweepToMove;
     rotationToMove;
     goToTriggered = new Subject();
@@ -7402,12 +9615,13 @@ class ViewerService {
         },
     };
     isObjectLoaded = false;
-    constructor(sdkKey, config, poiService, matterportService, threeJsService) {
+    constructor(sdkKey, config, poiService, matterportService, threeJsService, sweepLocator) {
         this.sdkKey = sdkKey;
         this.config = config;
         this.poiService = poiService;
         this.matterportService = matterportService;
         this.threeJsService = threeJsService;
+        this.sweepLocator = sweepLocator;
         this.setMode('Matterport');
     }
     /*-----------------------------------------------------------------------------------------------------------------
@@ -7613,14 +9827,77 @@ class ViewerService {
         if (![position?.x, position?.y, position?.z].every((value) => typeof value === 'number')) {
             return;
         }
+        const origin = getThreeJsPoiOrigin(poi);
         this.threeJsService.upsertTag({
             id: object.id,
             position,
             poiType: poi.type,
             label: object.name ?? object.title ?? null,
             iconUrl: await this.resolveTagIconUrl(poi),
+            originCaptureID: origin?.captureID ?? null,
+            frame: origin?.frame ?? null,
         });
     }
+    /**
+     * Stores the tags the last calibration had to rewrite, and returns how many it could not.
+     *
+     * Calibrating keeps the tags placed in this model where they are by changing their coordinates
+     * rather than their place (see ThreeJsService.applyAlignmentKeepingOwnTags). The scene already
+     * shows the result; this writes it down. Call it once the calibration itself is stored - with the
+     * old calibration still on record, the old coordinates are the ones that match it.
+     */
+    async persistRebasedThreeJsTags() {
+        const rebased = this.threeJsService.takeRebasedTags();
+        let failed = 0;
+        await Promise.all(rebased.map(async (tag) => {
+            try {
+                const poi = await this.poiService.getPoiByElementId(tag.id);
+                if (!poi?.id) {
+                    return;
+                }
+                let metadata = {};
+                try {
+                    metadata = (poi.metadata ? JSON.parse(poi.metadata) : {}) ?? {};
+                }
+                catch {
+                    metadata = {};
+                }
+                // In the shared space from here on, so no longer marked as being in the model's own.
+                delete metadata.frame;
+                if (metadata.normal) {
+                    metadata.normal = tag.rotateDirection(metadata.normal);
+                }
+                if (this.currentCaptureID) {
+                    metadata.captureID = this.currentCaptureID;
+                }
+                await this.poiService.updatePoi({
+                    id: poi.id,
+                    coordinate: JSON.stringify(tag.position),
+                    metadata: JSON.stringify(metadata),
+                    // Its place in the tour may have changed with its coordinates - or it may have one for
+                    // the first time, now that the model is calibrated.
+                    matterportSweepID: await this.findNearestSweepForThreeJs(tag.position),
+                });
+            }
+            catch (error) {
+                failed += 1;
+                console.warn(`ViewerService: could not store the new coordinates of tag ${tag.id}`, error);
+            }
+        }));
+        return { stored: rebased.length - failed, failed };
+    }
+    /** How many tags the calibration walkthrough could still use: the ones from elsewhere. */
+    getThreeJsCalibrationCandidateCount() {
+        return this.checkMode('threejs') ? this.threeJsService.getCalibrationCandidateCount() : 0;
+    }
+    /** How many tags from elsewhere are not on the 3D model, and so are not shown on it. */
+    getThreeJsOffModelTagCount() {
+        return this.checkMode('threejs') ? this.threeJsService.getOffModelTagCount() : 0;
+    }
+    /** The tags registered in the Three.js scene, shown or not. */
+    getThreeJsTags() {
+        return this.checkMode('threejs') ? this.threeJsService.getTags() : [];
+    }
     /**
      * The image to draw a tag with, mirroring what Matterport shows for the same POI.
      *
@@ -7713,6 +9990,7 @@ class ViewerService {
         if (!alignment) {
             return null;
         }
+        this.threeJsCalibrated = true;
         // Merged into whatever the capture already stores, so an existing camera placement survives.
         let stored = {};
         try {
@@ -7767,7 +10045,11 @@ class ViewerService {
         if (!this.checkMode('threejs')) {
             return;
         }
-        this.threeJsService.setTagAlignment(parseThreeJsPlacement(metadata)?.alignment ?? null);
+        const alignment = parseThreeJsPlacement(metadata)?.alignment ?? null;
+        this.threeJsCalibrated = !!alignment;
+        // Which tags were placed in this model is decided against the capture on screen.
+        this.threeJsService.setCurrentCapture(this.currentCaptureID);
+        this.threeJsService.setTagAlignment(alignment);
     }
     /**
      * Enable tag placement menu to add a new element depending on its type (TICKET, DATA, EQUIPMENT etc)
@@ -7836,22 +10118,116 @@ class ViewerService {
         if (this.checkMode('Matterport')) {
             await this.matterportService.action_toolbox_floorplan();
         }
-    }
-    action_toolbox_mesure() {
-        if (this.matterportService.getInteractionMode() !== ViewerInteractions.DEFAULT) {
-            this.action_canceled();
+    }
+    action_toolbox_mesure() {
+        if (this.matterportService.getInteractionMode() !== ViewerInteractions.DEFAULT) {
+            this.action_canceled();
+        }
+        this.action_toolbox_inside_view();
+        // Matterport
+        if (this.checkMode('Matterport')) {
+            this.matterportService.action_toolbox_mesure();
+        }
+        // Matterport's SDK brings its own measuring tool; the Three.js viewer has to provide one.
+        if (this.checkMode('threejs')) {
+            this.threeJsService.startMeasuring();
+        }
+    }
+    action_toolbox_cancel_mesure() {
+        // Matterport
+        if (this.checkMode('Matterport')) {
+            this.matterportService.action_toolbox_cancel_mesure();
+        }
+        if (this.checkMode('threejs')) {
+            this.threeJsService.cancelMeasuring();
+            // The toolbar toggles on this flag; left on, the next click would switch measuring "off"
+            // instead of starting a new one.
+            this.toolboxStates.mesure.stat = false;
+        }
+    }
+    /** While measuring in the Three.js viewer: points and segment lengths so far, null if abandoned. */
+    get threeJsMeasurementProgress$() {
+        return this.threeJsService.measurementProgress$;
+    }
+    /** Ends the Three.js measurement in progress, or returns null when it has fewer than two points. */
+    finishThreeJsMeasurement() {
+        if (!this.checkMode('threejs')) {
+            return null;
+        }
+        const measurement = this.threeJsService.finishMeasuring();
+        if (measurement) {
+            this.toolboxStates.mesure.stat = false;
+        }
+        return measurement;
+    }
+    /** The measurement last finished in the Three.js viewer, for the form that saves it. */
+    getThreeJsLastMeasurement() {
+        return this.checkMode('threejs') ? this.threeJsService.getLastMeasurement() : null;
+    }
+    /**
+     * The Matterport sweep nearest to a point picked in the Three.js viewer, or null.
+     *
+     * For callers that write their own POI, as the measurement form does - anything created through
+     * createPoiForThreeJsPlacement already gets this.
+     */
+    findNearestSweepForThreeJs(point) {
+        // An uncalibrated model's coordinates are its own. Measured against the Matterport sweeps they
+        // could land near one by coincidence, and the tag would turn up in the tour somewhere arbitrary.
+        if (!this.threeJsCalibrated) {
+            return Promise.resolve(null);
+        }
+        return this.sweepLocator.findNearestSweep(point, this.currentSpaceID);
+    }
+    /**
+     * The metadata a POI placed in the Three.js viewer is stored with: which 3D model it was placed
+     * in, and - when that model is not calibrated - that its coordinates are the model's own.
+     */
+    buildThreeJsPoiMetadata(extra = {}) {
+        return JSON.stringify({
+            ...extra,
+            ...(this.currentCaptureID ? { captureID: this.currentCaptureID } : {}),
+            ...(this.currentCaptureID && !this.threeJsCalibrated ? { frame: 'model' } : {}),
+        });
+    }
+    /** Which of the 3D model's axes is being treated as up. */
+    getThreeJsModelUp() {
+        return this.threeJsService.getModelUp();
+    }
+    /**
+     * Turns the 3D model to the next candidate for "which axis is up", and returns the capture
+     * metadata with that choice written in, for the caller to store.
+     *
+     * The vertical axis is worked out from the geometry when a model loads, and that can be wrong:
+     * a narrow corridor and a low slab are the same shape turned over. This is the way to correct it.
+     */
+    cycleThreeJsModelUp(existingMetadata) {
+        if (!this.checkMode('threejs')) {
+            return null;
+        }
+        const current = THREEJS_MODEL_UP_OPTIONS.indexOf(this.threeJsService.getModelUp());
+        const up = THREEJS_MODEL_UP_OPTIONS[(current + 1) % THREEJS_MODEL_UP_OPTIONS.length];
+        this.threeJsService.setModelUp(up);
+        let stored = {};
+        try {
+            stored = existingMetadata ? JSON.parse(existingMetadata) : {};
         }
-        this.action_toolbox_inside_view();
-        // Matterport
-        if (this.checkMode('Matterport')) {
-            this.matterportService.action_toolbox_mesure();
+        catch {
+            stored = {};
         }
+        stored.up = up;
+        return { up, metadata: JSON.stringify(stored) };
     }
-    action_toolbox_cancel_mesure() {
-        // Matterport
-        if (this.checkMode('Matterport')) {
-            this.matterportService.action_toolbox_cancel_mesure();
-        }
+    /** Chooses the tag for the calibration pair being matched by id, instead of by clicking it. */
+    selectThreeJsAlignmentTag(elementId) {
+        return this.checkMode('threejs') && this.threeJsService.selectAlignmentTag(elementId);
+    }
+    /** 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;
+    }
+    /** How many tags the Three.js scene is showing. */
+    getThreeJsTagCount() {
+        return this.checkMode('threejs') ? this.threeJsService.getTagCount() : 0;
     }
     async action_update_poi(poi, isValid, element) {
         if (this.checkMode('Matterport')) {
@@ -7941,11 +10317,15 @@ class ViewerService {
         if (!placement || !element?.id) {
             return null;
         }
+        // Without a sweep the tag is left off everything on the Matterport side that is organised by
+        // 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({
             coordinate: JSON.stringify(placement.position),
             type: poiType,
             elementID: element.id,
-            metadata: JSON.stringify({ normal: placement.normal }),
+            metadata: this.buildThreeJsPoiMetadata({ normal: placement.normal }),
+            ...(matterportSweepID ? { matterportSweepID } : {}),
         });
         // Draw it straight away rather than waiting for the next refresh, so the user sees where the
         // thing they just created ended up. Through the same path the refresh uses, so it arrives with
@@ -8075,7 +10455,7 @@ class ViewerService {
         const placement = parseThreeJsPlacement(placementMetadata);
         // The key, not the signed URL, is what identifies the model across loads - the signature makes
         // every URL unique, which is exactly why the browser's own cache never helps here.
-        this.threeJsService.loadGLTFModel(url, placement?.cameraPosition, placement?.rotation, key);
+        this.threeJsService.loadGLTFModel(url, placement?.cameraPosition, placement?.rotation, key, placement?.up);
     }
     /**
      * Loads a 3D model into the Three.js scene (OBJ).
@@ -8170,7 +10550,7 @@ class ViewerService {
     isObject3DLoadedInPosition() {
         return this.isObjectLoaded;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ViewerService, deps: [{ token: MATTERPORT_SDK_KEY }, { token: 'config' }, { token: PoiService }, { token: MatterportService }, { token: ThreeJsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ViewerService, deps: [{ token: MATTERPORT_SDK_KEY }, { token: 'config' }, { token: PoiService }, { token: MatterportService }, { token: ThreeJsService }, { token: SweepLocatorService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ViewerService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ViewerService, decorators: [{
@@ -8184,7 +10564,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }] }, { type: Config, decorators: [{
                     type: Inject,
                     args: ['config']
-                }] }, { type: PoiService }, { type: MatterportService }, { type: ThreeJsService }] });
+                }] }, { type: PoiService }, { type: MatterportService }, { type: ThreeJsService }, { type: SweepLocatorService }] });
 
 class ModalSwitchVisitComponent {
     activeModal;
@@ -8227,6 +10607,27 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Input
             }] } });
 
+/**
+ * Where a POI placed in a Three.js model says it was placed, or null for any other POI.
+ *
+ * `frame` is 'model' when its coordinates are in that model's own space - it was placed before the
+ * model was calibrated - rather than in the space tags share with the other visits.
+ */
+function getThreeJsPoiOrigin(poi) {
+    if (!poi?.metadata) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(poi.metadata);
+        return typeof parsed?.captureID === "string"
+            ? { captureID: parsed.captureID, frame: parsed.frame === "model" ? "model" : null }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+const THREEJS_MODEL_UP_OPTIONS = ["y", "z", "x", "-y", "-z", "-x"];
 /**
  * Parses the placement stored in a Three.js capture's metadata, or null when there is none.
  *
@@ -8265,7 +10666,12 @@ function parseThreeJsPlacement(metadata) {
                 placement.alignment = alignment;
             }
         }
-        return placement.cameraPosition || placement.rotation || placement.alignment ? placement : null;
+        if (THREEJS_MODEL_UP_OPTIONS.includes(parsed.up)) {
+            placement.up = parsed.up;
+        }
+        return placement.cameraPosition || placement.rotation || placement.alignment || placement.up
+            ? placement
+            : null;
     }
     catch {
         console.warn("Ignoring unparseable Three.js placement metadata:", metadata);
@@ -8690,285 +11096,57 @@ function shuffleArray(array) {
     const newArray = [...array];
     for (let index = array.length - 1; index > 0; index--) {
         const indexNew = Math.floor(Math.random() * (index + 1));
-        // eslint-disable-next-line no-param-reassign
-        [newArray[index], newArray[indexNew]] = [
-            newArray[indexNew],
-            newArray[index],
-        ];
-    }
-    return newArray;
-}
-function numberToDateString(timestamp) {
-    const jsDate = new Date(timestamp);
-    return jsDate.toLocaleString("fr-FR");
-}
-function durationToString(duration, translate) {
-    const days = Math.floor(duration / 3600 / 24);
-    const hours = Math.floor((duration - days * 24 * 3600) / 3600);
-    const minutes = Math.floor((duration % 3600) / 60);
-    const seconds = Math.floor(duration % 60);
-    const daysString = translate.instant("day(s)");
-    const hoursString = translate.instant("hour(s)");
-    const oneHourString = translate.instant("hour");
-    const minutesString = translate.instant("minute(s)");
-    const secondsString = translate.instant("second(s)");
-    if (duration > 3600 * 24 * 7) {
-        return `${days} ${daysString}`;
-    }
-    if (duration > 3600 * 24) {
-        return `${days} ${daysString} ${hours} ${hoursString}`;
-    }
-    if (duration === 3600) {
-        return `${hours} ${oneHourString}`;
-    }
-    if (duration > 3600) {
-        if (minutes === 0) {
-            return `${hours} ${hoursString}`;
-        }
-        return `${hours} ${hoursString} ${minutes} ${minutesString}`;
-    }
-    if (duration >= 60) {
-        if (seconds === 0) {
-            return `${minutes} ${minutesString}`;
-        }
-        return `${minutes} ${minutesString} ${seconds} ${secondsString}`;
-    }
-    return `${seconds} ${secondsString}`;
-}
-function pointToString(point) {
-    const x = point.x.toFixed(3);
-    const y = point.y.toFixed(3);
-    const z = point.z.toFixed(3);
-    return `{ x: ${x}, y: ${y}, z: ${z} }`;
-}
-
-/* eslint-disable class-methods-use-this */
-class ZoneService {
-    userService;
-    API; //AWS APIService
-    constructor(apiInjected, userService) {
-        this.userService = userService;
-        this.API = apiInjected;
-    }
-    async getZonesBySpace(spaceID) {
-        const list = [];
-        if (this.API.__proto__.hasOwnProperty('ZonesBySpace')) {
-            // Paginated: without a nextToken loop, only the first page (100 zones) was returned and
-            // the sweeps of the other zones silently disappeared.
-            let nextToken = null;
-            do {
-                const zones = await this.API.__proto__.ZonesBySpace(spaceID, null, null, 1000, nextToken);
-                for (const zone of zones?.items || []) {
-                    const zoneObject = { ...zone };
-                    zoneObject.virtual = this.zoneIsVirtual(zone);
-                    list.push(zoneObject);
-                }
-                nextToken = zones?.nextToken ?? null;
-            } while (nextToken);
-            return list;
-        }
-        else {
-            throw new Error('ZonesBySpace not implemented');
-        }
-    }
-    async getZonesBySpaceForUser(spaceID) {
-        const missionForLocation = this.userService.currentMission(spaceID);
-        const list = [];
-        if (missionForLocation && missionForLocation.zoneID) {
-            const allowedZone = await this.getZone(missionForLocation.zoneID);
-            allowedZone.virtual = this.zoneIsVirtual(allowedZone);
-            if (!allowedZone.parent) {
-                // the whole building is authorized
-                return this.getZonesBySpace(spaceID);
-            }
-            list.push(allowedZone);
-            // allow all children zones of an allowed parent
-            const children = (await this.API.__proto__.ZonesByZone(allowedZone.id))
-                .items;
-            if (children.length > 0) {
-                for (const child of children) {
-                    const childZone = { ...child };
-                    childZone.virtual = this.zoneIsVirtual(child);
-                    list.push(childZone);
-                }
-            }
-            // allow the parent Floor of the allowed zone
-            if (allowedZone.parent.layer &&
-                allowedZone.parent.layer.name === 'FLOOR') {
-                list.push(allowedZone.parent);
-            }
-        }
-        else {
-            return this.getZonesBySpace(spaceID);
-        }
-        return list;
-    }
-    async filterZonesIDsForUser(zones) {
-        const { spaceID } = zones[0];
-        const zoneIDs = new Set(zones.map((zone) => zone.id));
-        const allowedZones = await this.getZonesBySpaceForUser(spaceID);
-        const filteredZones = allowedZones.filter((zone) => zoneIDs.has(zone.id));
-        return filteredZones;
-    }
-    async deleteZone(zoneID) {
-        return this.API.__proto__.DeleteZone({ id: zoneID });
-    }
-    async getZonesForSweepForSpace(sweepID, spaceID) {
-        const zonesSpace = (await this.API.__proto__.ZonesBySpace(spaceID)).items;
-        return zonesSpace.filter((zone) => zone.sweepIDs && zone.sweepIDs.includes(sweepID));
-    }
-    // // eslint-disable-next-line class-methods-use-this
-    sortZonesFromChildToParent(zonesToSort) {
-        // get default
-        const defaultZone = zonesToSort.find((z) => !z.parentID);
-        if (defaultZone) {
-            const indexOf = zonesToSort.indexOf(defaultZone);
-            zonesToSort.splice(indexOf, 1);
-        }
-        const zones = zonesToSort.sort((a, b) => {
-            if (a.parentID === b.id) {
-                return -1;
-            }
-            return 0;
-        });
-        // so far by number of navigation points in them
-        // const zones = zonesToSort.sort(
-        //     (a, b) => a.navigations.items.length - b.navigations.items.length,
-        // );
-        if (defaultZone) {
-            zones.push(defaultZone);
-        }
-        return zones;
-    }
-    async getZonesForObject(object) {
-        if (object.pois.items && object.pois.items.length > 0) {
-            const [poi] = object.pois.items;
-            if (poi.matterportSweepID) {
-                const zones = await this.getZonesForSweepForSpace(poi.matterportSweepID, object.spaceID);
-                return zones;
-            }
-        }
-        return null;
-    }
-    async createVirtualZone(zoneInput) {
-        zoneInput.sweepIDs = [];
-        const zone = await this.API.__proto__.CreateZone(zoneInput);
-        console.log('virtual zone created', zone);
-        return zone;
-    }
-    zoneIsVirtual(zone) {
-        if (!zone.sweepIDs) {
-            return true;
-        }
-        if ((zone.tags && zone.tags.includes('virtual')) ||
-            zone.sweepIDs.length === 0) {
-            return true;
-        }
-        return false;
-    }
-    async getModel3DForZone(zoneID) {
-        const zone = await this.API.__proto__.GetZone(zoneID);
-        if (zone.nodeIDs) {
-            const node = await this.API.__proto__.GetNode(zone.nodeIDs[0]);
-            return node.model3D;
-        }
-        return null;
-    }
-    async getZone(zoneID) {
-        return this.API.__proto__.GetZone(zoneID);
-    }
-    async getDefaultZoneForSpace(spaceID) {
-        return this.getZonesBySpace(spaceID).then(async (zones) => {
-            const zonesBuilding = zones.filter((zone) => zone.layer && zone.layer.name === 'BUILDING');
-            if (zonesBuilding.length === 1) {
-                return zonesBuilding[0];
-            }
-            const parentZone = zones.find((zone) => !zone.parentID);
-            return parentZone;
-        });
-    }
-    async create(input) {
-        return this.API.__proto__.CreateZone(input);
-    }
-    // async getSortedZonesForSweepForUser(
-    //     sweep: string,
-    //     spaceID: string,
-    // ): Promise<Zone[]> {
-    //     if (!spaceID) {
-    //         return [];
-    //     }
-    //     const zones = await this.getZonesForSweepForSpace(sweep, spaceID);
-    //     if (zones.length === 0) {
-    //         return [];
-    //     }
-    //     const filteredZones = await this.filterZonesIDsForUser(zones);
-    //     if (filteredZones.length > 0) {
-    //         let zonesSorted = this.sortZonesFromChildToParent(filteredZones);
-    //         zonesSorted = zonesSorted.filter((zone) => zone !== undefined);
-    //         return zonesSorted;
-    //     }
-    //     return [];
-    // }
-    async updateZone(input) {
-        return this.API.__proto__.UpdateZone(input);
+        // eslint-disable-next-line no-param-reassign
+        [newArray[index], newArray[indexNew]] = [
+            newArray[indexNew],
+            newArray[index],
+        ];
     }
-    async getZonesForNodeForSpace(nodeID, spaceID) {
-        return this.API.__proto__.ZonesBySpace(spaceID).then(async (zones) => {
-            const filteredZones = zones.items.filter((zone) => zone.nodeIDs && zone.nodeIDs.includes(nodeID));
-            return filteredZones;
-        });
+    return newArray;
+}
+function numberToDateString(timestamp) {
+    const jsDate = new Date(timestamp);
+    return jsDate.toLocaleString("fr-FR");
+}
+function durationToString(duration, translate) {
+    const days = Math.floor(duration / 3600 / 24);
+    const hours = Math.floor((duration - days * 24 * 3600) / 3600);
+    const minutes = Math.floor((duration % 3600) / 60);
+    const seconds = Math.floor(duration % 60);
+    const daysString = translate.instant("day(s)");
+    const hoursString = translate.instant("hour(s)");
+    const oneHourString = translate.instant("hour");
+    const minutesString = translate.instant("minute(s)");
+    const secondsString = translate.instant("second(s)");
+    if (duration > 3600 * 24 * 7) {
+        return `${days} ${daysString}`;
     }
-    /**
-     * Gets the Zone (layer FLOOR) for a matterport sweep ID in a given Space
-     * @param sweepID
-     * @param spaceID
-     * @returns Zone
-     */
-    async getFloorZoneForSweepInSpace(sweepID, spaceID) {
-        const zones = await this.getZonesForSweepForSpace(sweepID, spaceID);
-        const floors = zones.filter((zone) => zone.layer && zone.layer.name.includes('FLOOR'));
-        return floors.length > 0 ? floors[0] : null;
+    if (duration > 3600 * 24) {
+        return `${days} ${daysString} ${hours} ${hoursString}`;
     }
-    /**
-     * Get zones with audio track for entire space
-     * @param spaceID
-     * @returns  Promise<Zone[]>
-     */
-    async getAudioZonesForSpace(spaceID) {
-        const allZones = await this.getZonesBySpace(spaceID);
-        return allZones.filter((zone) => zone.audioID);
+    if (duration === 3600) {
+        return `${hours} ${oneHourString}`;
     }
-    /**
-     * Get audio zones for user (within allowed zones)
-     * @param spaceID
-     * @returns  Promise<Zone[]>
-     */
-    async getAudioZonesForUserForSpace(spaceID) {
-        const userZones = await this.getZonesBySpaceForUser(spaceID);
-        return userZones.filter((zone) => zone.audioID);
+    if (duration > 3600) {
+        if (minutes === 0) {
+            return `${hours} ${hoursString}`;
+        }
+        return `${hours} ${hoursString} ${minutes} ${minutesString}`;
     }
-    /**
-     * Get Zones by Parent Zone ID
-     * @param parentZoneID string
-     * @returns Promise<Zone[]>
-     */
-    async getZonesByParentZone(parentZoneID) {
-        return this.API.__proto__
-            .ZonesByZone(parentZoneID)
-            .then((res) => res.items);
+    if (duration >= 60) {
+        if (seconds === 0) {
+            return `${minutes} ${minutesString}`;
+        }
+        return `${minutes} ${minutesString} ${seconds} ${secondsString}`;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ZoneService, deps: [{ token: 'currentAPIService' }, { token: BaseUserService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ZoneService, providedIn: 'root' });
+    return `${seconds} ${secondsString}`;
+}
+function pointToString(point) {
+    const x = point.x.toFixed(3);
+    const y = point.y.toFixed(3);
+    const z = point.z.toFixed(3);
+    return `{ x: ${x}, y: ${y}, z: ${z} }`;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ZoneService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['currentAPIService']
-                }] }, { type: BaseUserService }] });
 
 /* eslint-disable no-case-declarations */
 /* eslint-disable no-await-in-loop */
@@ -9186,7 +11364,12 @@ class FilterService {
                 // visibility filter already reads "no sweep" as "not floor-scoped, show it";
                 // this is the same rule applied to zones.
                 if (poi && poi.coordinate && !poi.matterportSweepID) {
-                    filteredObjects.push(object);
+                    // ...unless it was placed in a 3D model. With no sweep, that model was never
+                    // tied to this tour: the coordinates are the model's own, and here they would
+                    // put the tag somewhere arbitrary.
+                    if (!getThreeJsPoiOrigin(poi)) {
+                        filteredObjects.push(object);
+                    }
                     return;
                 }
                 if (poi && zone) {
@@ -9581,133 +11764,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }]
         }], ctorParameters: () => [{ type: BaseUserService }, { type: ZoneService }, { type: PoiService }] });
 
-class NavigationService {
-    userService;
-    zoneService;
-    API;
-    constructor(apiInjected, userService, zoneService) {
-        this.userService = userService;
-        this.zoneService = zoneService;
-        this.API = apiInjected;
-    }
-    async createNavigation(navInput) {
-        return this.API.__proto__.CreateNavigation(navInput);
-    }
-    async deleteNavigation(id) {
-        return this.API.__proto__.DeleteNavigation({ id });
-    }
-    async getNavigationsForNode(nodeID) {
-        const limit = 200;
-        let navigationsTokenDict = { navigations: [], nextToken: null };
-        do {
-            navigationsTokenDict =
-                await this.mergeAPIResponseWithNextTokenWithLimit(nodeID, limit, navigationsTokenDict);
-        } while (navigationsTokenDict.nextToken);
-        return navigationsTokenDict.navigations;
-    }
-    async mergeAPIResponseWithNextTokenWithLimit(nodeID, limit, navigationsTokenDict) {
-        return this.API.__proto__.NavigationsByNode(nodeID, null, null, limit, navigationsTokenDict.nextToken).then((response) => {
-            const navigations = response.items;
-            const navObject = {
-                navigations: [...navigationsTokenDict.navigations, ...navigations],
-                nextToken: response.nextToken,
-            };
-            return navObject;
-        });
-    }
-    async getNavigation(id) {
-        return this.API.__proto__.GetNavigation(id);
-    }
-    async getSweepsIDsForSpace(spaceID) {
-        const zones = await this.zoneService.getZonesBySpace(spaceID);
-        const zonesWithSweeps = zones.filter((zone) => zone.sweepIDs && zone.sweepIDs.length > 0);
-        const allSweeps = zonesWithSweeps.flatMap((zone) => zone.sweepIDs);
-        return [...new Set(allSweeps)];
-    }
-    async getAllowedSweepsIDsForUserInSpace(spaceID) {
-        const missionsForSpace = this.userService.currentMissions.filter((mis) => mis.spaceID === spaceID);
-        console.log(missionsForSpace);
-        let navIDs = [];
-        if (this.userService.userHasAccessToAllZonesInSpace(spaceID)) {
-            console.log(1);
-            return this.getSweepsIDsForSpace(spaceID);
-        }
-        await Promise.all(missionsForSpace.map(async (mission) => {
-            navIDs = [...navIDs, ...mission.zone.sweepIDs];
-        }));
-        console.log('final navids = ', navIDs);
-        return navIDs;
-    }
-    async getForbiddenNavigationIDsForUserInSpace(spaceID) {
-        const allowed = await this.getAllowedSweepsIDsForUserInSpace(spaceID);
-        const allNavs = await this.getSweepsIDsForSpace(spaceID);
-        const difference = allNavs.filter((x) => !allowed.includes(x));
-        return difference.length > 0 ? difference : null;
-    }
-    async getNavigationsForMatterportIDForSpace(matterportID, spaceID) {
-        return this.API.__proto__.NavigationsByMatterportIDBySpace(matterportID, {
-            eq: spaceID,
-        }).then((navs) => navs.items);
-    }
-    async getNavigationsForZone(zone) {
-        const responseNavs = [];
-        await Promise.all(zone.sweepIDs.map(async (sweepID) => {
-            const navs = await this.getNavigationsForMatterportIDForSpace(sweepID, zone.spaceID);
-            if (navs.length > 0) {
-                responseNavs.push(navs[0]);
-            }
-        }));
-        return responseNavs;
-    }
-    async updateNavigation(navInput) {
-        return this.API.__proto__.UpdateNavigation(navInput);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, deps: [{ token: 'currentAPIService' }, { token: BaseUserService }, { token: ZoneService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, providedIn: "root" });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavigationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['currentAPIService']
-                }] }, { type: BaseUserService }, { type: ZoneService }] });
-
-class CaptureService {
-    API; //AWS
-    constructor(apiInjected) {
-        this.API = apiInjected;
-    }
-    async getCapturesBySpace(spaceID) {
-        return this.API.CapturesBySpace(spaceID).then((cap) => cap.items);
-    }
-    async getCapture(captureID) {
-        return this.API.__proto__.GetCapture(captureID);
-    }
-    async deleteCapture(captureID) {
-        return this.API.__proto__.DeleteCapture({ id: captureID });
-    }
-    async updateCapture(capture) {
-        return this.API.__proto__.UpdateCapture(capture);
-    }
-    async createCapture(capture) {
-        return this.API.__proto__.CreateCapture(capture);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaptureService, deps: [{ token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaptureService, providedIn: "root" });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CaptureService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['currentAPIService']
-                }] }] });
-
 class NodeService {
     API;
     constructor(apiInjected) {
@@ -11043,7 +13099,7 @@ class BaseObjectService {
             // is no sweep to resolve a visit from, which is why this used to report the model
             // as unreachable. The space's 3D visit is the one that can show it.
             if (poi && poi.coordinate && !poi.matterportSweepID) {
-                const visit = await this.getThreeJsVisitForSpace(object.spaceID);
+                const visit = await this.getThreeJsVisitForSpace(object.spaceID, getThreeJsPoiOrigin(poi)?.captureID);
                 return visit
                     ? { model3D: visit.model3d, sweep: null, rotation: null }
                     : null;
@@ -11079,15 +13135,15 @@ class BaseObjectService {
         });
     }
     /**
-     * The space's 3D visit, or null when it has none.
+     * The 3D visit to show a POI in, or null when the space has none.
      *
-     * Takes the first one the database returns. That is not the space's chosen default - the
-     * default ordering lives in SpaceService, which cannot be injected here. The POI does not record
-     * which capture it was placed in, so with several 3D models this is a guess either way.
+     * The one the POI was placed in, when it says. Older POIs do not, and for those it is the first
+     * 3D visit the database returns - a guess, when the space has several.
      */
-    async getThreeJsVisitForSpace(spaceID) {
-        const visits = await this.visitService.getVisitsForSpaceForUser(spaceID, false);
-        return (visits ?? []).find((visit) => visit.viewer === CaptureViewer.THREEJS) ?? null;
+    async getThreeJsVisitForSpace(spaceID, captureID) {
+        const visits = (await this.visitService.getVisitsForSpaceForUser(spaceID, false) ?? [])
+            .filter((visit) => visit.viewer === CaptureViewer.THREEJS);
+        return visits.find((visit) => visit.captureID === captureID) ?? visits[0] ?? null;
     }
     async updateIconForAllObjects(objects, tagIcon) {
         const IDs = [];
@@ -12483,7 +14539,7 @@ class EquipmentService extends BaseObjectService {
                     user: this.userService.cu,
                     locationId: this.currentSpaceID,
                     timestamp: new Date(),
-                    zoneId: this.currentZone.id,
+                    zoneId: this.currentZone?.id,
                     floorId: this.selectedFloor?.id,
                 },
                 streamName: 'smarterplanKinesis-analytics',
@@ -12947,6 +15003,11 @@ class EquipmentService extends BaseObjectService {
     }
     updateDueToCreate(createdEquip) {
         this.currentEquipments.space.unshift(createdEquip);
+        // initEquips only records a zone's list when it has a zone or found equipments, so the first
+        // equipment of a space viewed without zones (Three.js) arrives with no list to join.
+        if (!this.currentEquipments.zonesMap.has(this.zoneIDFilter)) {
+            this.currentEquipments.zonesMap.set(this.zoneIDFilter, []);
+        }
         this.currentEquipments.zonesMap
             .get(this.zoneIDFilter)
             .unshift(createdEquip);
@@ -13020,6 +15081,26 @@ class EquipmentService extends BaseObjectService {
                 }
             }
         });
+        // The Three.js viewer shows a whole space at once, with no zone to navigate into, so it
+        // announces itself here instead of through `zoneChange`. Leaving the zone filter empty is what
+        // makes every equipment of the space show up.
+        this.zoneChangeService.spaceWithoutZones
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((spaceID) => {
+            this.currentSpaceID = spaceID;
+            this.zoneIDFilter = null;
+            this.currentZone = null;
+            this.currentEquipments = {
+                space: [],
+                zonesMap: new Map(),
+            };
+            if (!spaceID) {
+                this.equipmentsTags.next(null);
+                this.equipmentsUpdated.next({ space: [], zone: null });
+                return;
+            }
+            this.initEquips();
+        });
         this.deleteObservable
             .pipe(takeUntil(this.destroy$))
             .subscribe((equipment) => {
@@ -13994,6 +16075,19 @@ class FeatureService extends BaseObjectService {
                 this.initFeatures();
             }
         });
+        // The Three.js viewer shows a whole space at once, with no zone to navigate into, so it
+        // announces itself here instead of through `zoneChange`.
+        this.zoneChangeService.spaceWithoutZones.subscribe((spaceID) => {
+            this.currentSpaceID = spaceID;
+            this.zoneIDFilter = null;
+            if (!spaceID) {
+                this.featureTags.next(null);
+                this.featureUpdated.next({ space: [], zone: null });
+            }
+            else if (!this.userService.isMuseumUser(spaceID)) {
+                this.initFeatures();
+            }
+        });
         this.updateDone.subscribe(() => {
             if (this.currentSpaceID) {
                 this.initFeatures();
@@ -14384,6 +16478,19 @@ class MeasurementService {
                     this.initMeasurements();
                 }
             });
+            // The Three.js viewer shows a whole space at once, with no zone to navigate into, so it
+            // announces itself here instead of through `zoneChange`.
+            this.zoneChangeService.spaceWithoutZones.subscribe((spaceID) => {
+                this.currentSpaceID = spaceID;
+                this.zoneIDFilter = null;
+                if (!spaceID) {
+                    this.measurementsTags.next(null);
+                    this.measurementsUpdated.next({ space: [], zone: null });
+                    this.measurementFilter = null;
+                    return;
+                }
+                this.initMeasurements();
+            });
             this.filterService.subscribeToDataFilterUpdate((dateRange) => {
                 this.dateFilter = dateRange;
                 this.initMeasurements();
@@ -14460,6 +16567,9 @@ class MeasurementService {
             type: PoiType.MEASURE,
             elementID: comment.id,
             matterportSweepID: sweepID,
+            // Only the Three.js viewer sends this: it records which 3D model the measurement was taken
+            // in, the same as createPoiForThreeJsPlacement does for the other tags.
+            ...(dataMeasurements.metadata ? { metadata: dataMeasurements.metadata } : {}),
         };
         const poi = await this.poiService.createPOIForSpaceID(poiInput);
         const screen = await fetch(screenshot);
@@ -19306,5 +21416,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, 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, 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, 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 };
 //# sourceMappingURL=smarterplan-ngx-smarterplan-core.mjs.map