@smarterplan/ngx-smarterplan-core 1.4.15 → 1.4.17

package/esm2022/lib/services/threejs.service.mjs

@@ -0,0 +1,1587 @@
+import { Injectable } from '@angular/core';
+import * as THREE from 'three';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
+import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader';
+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 { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * Returns null when the points are collinear or degenerate, because a wrong alignment applied
+ * silently is worse than none.
+ */
+export function solveThreeJsAlignment(pairs) {
+    if (!pairs || pairs.length < 3) {
+        return null;
+    }
+    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]);
+    const targetFrame = frameFromPoints(targets[0], targets[1], targets[2]);
+    if (!sourceFrame || !targetFrame) {
+        return null;
+    }
+    // A rotation's inverse is its transpose, so this is the rotation carrying one frame onto the other.
+    const rotation = targetFrame.multiply(sourceFrame.clone().transpose());
+    // Scale from how far apart the points are in each space, averaged over the three edges so a single
+    // sloppy click does not set it on its own.
+    const edges = [[0, 1], [1, 2], [0, 2]];
+    let ratioSum = 0;
+    let ratioCount = 0;
+    for (const [i, j] of edges) {
+        const sourceLength = sources[i].distanceTo(sources[j]);
+        const targetLength = targets[i].distanceTo(targets[j]);
+        if (sourceLength > 1e-9) {
+            ratioSum += targetLength / sourceLength;
+            ratioCount += 1;
+        }
+    }
+    if (ratioCount === 0) {
+        return null;
+    }
+    const scale = ratioSum / ratioCount;
+    // The group applies position, then rotation, then scale, so a point lands at t + s*R*p. Solving
+    // that for t at the centroids gives the translation.
+    const sourceCentroid = sources.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);
+    const targetCentroid = targets.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);
+    const translation = targetCentroid
+        .clone()
+        .sub(sourceCentroid.clone().applyMatrix4(rotation).multiplyScalar(scale));
+    const euler = new THREE.Euler().setFromRotationMatrix(rotation);
+    return {
+        translation: { x: translation.x, y: translation.y, z: translation.z },
+        rotation: { x: euler.x, y: euler.y, z: euler.z },
+        scale,
+    };
+}
+export class ThreeJsService {
+    ngZone;
+    scene;
+    camera;
+    renderer;
+    controls;
+    animationFrameId;
+    // Raycasting and interaction
+    raycaster = new THREE.Raycaster();
+    mouse = new THREE.Vector2();
+    isDraggingCamera = false;
+    isDraggingTimer;
+    clickableObjects = [];
+    // Observables for the viewer component
+    objectHovered$ = new Subject();
+    objectClicked$ = new Subject();
+    /** Emits when the user clicks a tag, mirroring Matterport's tag click. */
+    tagClicked$ = new Subject();
+    /** Emits a tag's label while the pointer is over it, and null when it leaves. */
+    tagHovered$ = new Subject();
+    // Tags live under the model rather than the scene, so the centering and scaling applied when the
+    // model is placed carries over and POI coordinates can stay in the model's own space.
+    tagGroup = new THREE.Group();
+    tagSprites = new Map();
+    canvasResizeObserver;
+    /** Aborts the in-flight model download. Parsing cannot be interrupted, only not started. */
+    loadAbortController;
+    // The loaded base model, kept so tag placement can raycast against its geometry.
+    modelRoot;
+    /** True while the next click on the model places a tag instead of orbiting. */
+    placingTag = false;
+    /** What the armed placement is for, echoed back when the spot is picked. */
+    placementPoiType = null;
+    /** Position and normal of the last placed tag, in model space, awaiting commit to a POI. */
+    pendingTagPlacement = null;
+    /** Pointer position waiting for a preview pick, coalesced to one per frame. */
+    pendingPreviewEvent = null;
+    /**
+     * Layer carrying the model alone, so the depth pick can render it without the tags.
+     *
+     * Layers are tested per object at render time and children are traversed regardless of whether
+     * their parent passed, so marking the model's own meshes is enough - no re-parenting.
+     */
+    static PICK_LAYER = 1;
+    /** Cache Storage bucket holding downloaded models, and how many to keep. */
+    static MODEL_CACHE = 'smarterplan-3d-models';
+    static MODEL_CACHE_SIZE = 3;
+    pickTarget;
+    pickCamera;
+    pickDepthMaterial;
+    pickPixel = new Uint8Array(4);
+    /** Emits once a tag is dropped on the model, so the UI can confirm and persist it. */
+    tagPlaced$ = new Subject();
+    /** Emits when the calibration walkthrough is abandoned, so the panel driving it can close. */
+    alignmentCancelled$ = new Subject();
+    /** Translucent marker shown under the cursor while placing. */
+    placementPreview;
+    aligning = false;
+    alignmentPairs = [];
+    alignmentSource = null;
+    /** 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. */
+    cameraTween = null;
+    /** Emits true while a heavy OBJ file is being parsed (in a worker, when available), false once done. */
+    modelLoading$ = new Subject();
+    /**
+     * Download progress for GLB models, as a 0-1 fraction, or null when the total size is unknown.
+     *
+     * A null means the server did not send Content-Length (chunked responses, some proxies) and no
+     * percentage can be derived; show an indeterminate indicator rather than guessing at one.
+     */
+    modelLoadProgress$ = new Subject();
+    /**
+     * Emits when a load actually stopped short, which is not the same as asking it to.
+     *
+     * cancelModelLoad() can arrive after parse() has taken the main thread, and parse cannot be
+     * interrupted - the model finishes loading regardless. Only this tells the UI which of the two
+     * happened, so it does not offer to reload something that is already on screen.
+     */
+    modelLoadCancelled$ = new Subject();
+    // Background parsing of heavy .obj files, provided by the hosting app (see setObjParserWorker).
+    // Angular libraries built with ng-packagr can't bundle `new Worker(new URL(...))` themselves,
+    // so the app instantiates the worker (its build pipeline supports it) and hands it over here.
+    objParserWorker;
+    objParserPendingRequests = new Map();
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+    }
+    /**
+     * Registers a Web Worker used to parse heavy .obj files off the main thread.
+     * Must be instantiated by the consuming app (e.g. `new Worker(new URL('./obj-parser.worker', import.meta.url))`),
+     * since a library packaged with ng-packagr cannot bundle worker files itself.
+     * When no worker is provided, loadObjModel falls back to parsing on the main thread.
+     */
+    setObjParserWorker(worker) {
+        this.objParserWorker = worker;
+        this.objParserWorker.onmessage = ({ data }) => {
+            const pending = this.objParserPendingRequests.get(data.requestId);
+            if (!pending) {
+                return;
+            }
+            this.objParserPendingRequests.delete(data.requestId);
+            if (data.success && data.meshes) {
+                pending.resolve(data.meshes);
+            }
+            else {
+                pending.reject(new Error(data.error || 'Unknown error while parsing OBJ file in worker'));
+            }
+        };
+    }
+    requestObjParseInWorker(objUrl) {
+        return new Promise((resolve, reject) => {
+            const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            this.objParserPendingRequests.set(requestId, { resolve, reject });
+            this.objParserWorker.postMessage({ requestId, objUrl });
+            // Diagnostic only: large models legitimately take a while, this isn't a timeout/abort,
+            // just a signal in case the worker went silent (e.g. it ran out of memory mid-parse).
+            setTimeout(() => {
+                if (this.objParserPendingRequests.has(requestId)) {
+                    console.warn(`ThreeJsService: obj-parser worker has not replied after 60s for request ${requestId} (objUrl=${objUrl}). Still waiting - large files can take a while, but this may also mean the worker hung or ran out of memory.`);
+                }
+            }, 60000);
+        });
+    }
+    /** Rebuilds a THREE.Mesh from the raw typed arrays sent back by the parser worker. */
+    meshFromParsedData(data, materials) {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.BufferAttribute(data.position, 3));
+        if (data.uv) {
+            geometry.setAttribute('uv', new THREE.BufferAttribute(data.uv, 2));
+        }
+        // Index has to be set before any normal computation, which reads it to average shared faces.
+        if (data.index) {
+            geometry.setIndex(new THREE.BufferAttribute(data.index, 1));
+        }
+        if (data.normal) {
+            geometry.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));
+        }
+        else {
+            geometry.computeVertexNormals();
+        }
+        // Box3.setFromObject() reuses an already-set boundingBox instead of walking every vertex,
+        // so adopting the worker's makes framing the camera cheap no matter how dense the mesh is.
+        if (data.boundingBox) {
+            geometry.boundingBox = new THREE.Box3(new THREE.Vector3(...data.boundingBox.min), new THREE.Vector3(...data.boundingBox.max));
+        }
+        const resolvedMaterials = data.materialNames.map((name) => {
+            const material = materials && name ? materials.create(name) : undefined;
+            if (!material) {
+                console.warn(`ThreeJsService: no MTL material named "${name}" for mesh "${data.name}", using a plain fallback (no texture).`);
+            }
+            return material || new THREE.MeshPhongMaterial();
+        });
+        let mesh;
+        if (data.groups && data.groups.length > 0) {
+            data.groups.forEach((group) => geometry.addGroup(group.start, group.count, group.materialIndex));
+            mesh = new THREE.Mesh(geometry, resolvedMaterials);
+        }
+        else {
+            mesh = new THREE.Mesh(geometry, resolvedMaterials[0]);
+        }
+        mesh.name = data.name;
+        return mesh;
+    }
+    init(canvas) {
+        // This service is a singleton but the viewer component is rebuilt on every navigation, so state
+        // from the previous scene is still here. Two things outlive it and have to go first:
+        //
+        //  - A download still in flight. Its onLoaded resolves against whatever `this.scene` points at
+        //    by then, so the model being abandoned would be handed to the scene built below.
+        //  - The tag group, which is a field and keeps its sprites. They would be re-parented under the
+        //    new model and show the previous visit's tags on it.
+        this.discardCurrentLoad();
+        this.clearTags();
+        this.cameraTween = null;
+        this.modelRoot = undefined;
+        // 1. Setup Scene
+        this.scene = new THREE.Scene();
+        this.scene.background = new THREE.Color(0xe0f7ff); // from POC
+        // 2. Setup Camera
+        this.camera = new THREE.PerspectiveCamera(75, canvas.clientWidth / canvas.clientHeight, 0.1, 10000);
+        this.camera.position.set(0, 5, 10); // will be overridden later if passed
+        // 3. Setup WebGL Renderer
+        this.renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
+        this.renderer.setSize(canvas.clientWidth, canvas.clientHeight);
+        this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));
+        this.observeCanvasResize(canvas);
+        // Fix for Three.js r147 vs r152+ color management
+        if ('outputColorSpace' in this.renderer) {
+            this.renderer.outputColorSpace = 'srgb'; // THREE.SRGBColorSpace
+        }
+        else {
+            this.renderer.outputEncoding = 3001; // THREE.sRGBEncoding
+        }
+        // Without tone mapping anything brighter than 1.0 is simply cut off to pure white. Captured
+        // textures carry a small fraction of very bright pixels - sky reflected in windows, sunlit
+        // render - and once lighting pushes those past the limit they flatten into white specks with
+        // no detail left. Rolling the highlights off instead keeps that detail and keeps bright areas
+        // reading as bright rather than blown.
+        this.renderer.toneMapping = THREE.ACESFilmicToneMapping;
+        this.renderer.toneMappingExposure = 1.0;
+        // 4. Lighting, kept deliberately restrained and neutral.
+        //
+        // Captured/photogrammetry models already have lighting baked into their textures (the sun and
+        // shadows came with the photos), so lighting them again distorts what they actually look like.
+        // The intensities below add up to roughly 1.0 on a surface facing the viewer, which renders the
+        // texture at its true value. Anything above 1.0 is clipped to pure white by the renderer, which
+        // is what turns bright areas into flat white patches with no detail left in them.
+        //
+        // Neutral white is used rather than a warm tint for the same reason: a tinted light shifts every
+        // colour in the model away from what was captured.
+        const ambientLight = new THREE.AmbientLight(0xffffff, 0.7);
+        this.scene.add(ambientLight);
+        // Headlight rather than a fixed sun: parented to the camera so it always points at whatever is
+        // being looked at, giving shape to surfaces without ever leaving a face unlit. No shadow casting
+        // - shadows would double up with the ones already baked into the textures, and the shadow map
+        // was a real cost per frame.
+        const headLight = new THREE.DirectionalLight(0xffffff, 0.35);
+        headLight.position.set(0, 0, 1);
+        this.camera.add(headLight);
+        // A light only contributes while it is part of the scene graph, and this one hangs off the camera.
+        this.scene.add(this.camera);
+        // 5. Setup Controls (from POC)
+        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
+        this.controls.rotateSpeed = 1.0;
+        this.controls.dampingFactor = 0.1;
+        this.controls.enableDamping = true;
+        this.controls.mouseButtons = {
+            LEFT: THREE.MOUSE.ROTATE,
+            MIDDLE: THREE.MOUSE.DOLLY,
+            RIGHT: THREE.MOUSE.PAN,
+        };
+        this.controls.target.set(0, 0, 0);
+        // Event listeners on controls to differentiate dragging vs clicking
+        this.controls.addEventListener('start', () => {
+            this.isDraggingTimer = setTimeout(() => {
+                this.isDraggingCamera = true;
+            }, 150);
+        });
+        this.controls.addEventListener('end', () => {
+            clearTimeout(this.isDraggingTimer);
+            if (this.isDraggingCamera) {
+                setTimeout(() => {
+                    this.isDraggingCamera = false;
+                }, 250);
+            }
+        });
+        // Interaction Event Listeners on canvas
+        canvas.addEventListener('click', this.onMouseClick.bind(this), false);
+        canvas.addEventListener('mousemove', this.onMouseMove.bind(this), false);
+        // Escape backs out of placement and calibration. On the window rather than the canvas, which
+        // would need focus the user has no reason to have given it - they are aiming with the mouse.
+        // Removed first because this service is a singleton: init() runs again for every canvas, and
+        // the previous registration would otherwise still be attached.
+        window.removeEventListener('keydown', this.onKeyDown);
+        this.pickTarget?.dispose();
+        this.pickTarget = undefined;
+        this.pickDepthMaterial?.dispose();
+        this.pickDepthMaterial = undefined;
+        this.pickCamera = undefined;
+        window.addEventListener('keydown', this.onKeyDown);
+        // 6. Start the render loop
+        this.ngZone.runOutsideAngular(() => {
+            this.animate();
+        });
+    }
+    /**
+     * Path (served by the app) holding basis_transcoder.js/.wasm, which KTX2Loader needs to turn
+     * Basis Universal textures into whatever compressed format the local GPU actually supports.
+     */
+    ktx2TranscoderPath = 'assets/basis/';
+    /** Overrides where the Basis transcoder files are served from. */
+    setKtx2TranscoderPath(path) {
+        this.ktx2TranscoderPath = path;
+    }
+    /**
+     * Loads a base 3D model in GLTF/GLB format - the preferred format for large models.
+     * Unlike .obj, geometry arrives as binary typed arrays (no text parsing to offload to a worker)
+     * 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) {
+        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.
+        if (this.renderer) {
+            try {
+                const ktx2Loader = new KTX2Loader()
+                    .setTranscoderPath(this.ktx2TranscoderPath)
+                    .detectSupport(this.renderer);
+                loader.setKTX2Loader(ktx2Loader);
+            }
+            catch (error) {
+                console.warn('ThreeJsService: could not set up KTX2 texture support, falling back to uncompressed textures.', error);
+            }
+        }
+        // Lets gltfpack/gltf-transform output using EXT_meshopt_compression load without extra setup.
+        loader.setMeshoptDecoder(MeshoptDecoder);
+        this.modelLoading$.next(true);
+        this.modelLoadProgress$.next(0);
+        // Order matters: normals must exist before anisotropy, and the Phong conversion has to run
+        // before side/flatShading are touched so those settings land on the materials we keep.
+        const onLoaded = (gltf) => {
+            this.convertToPhongMaterials(gltf.scene);
+            this.forceDoubleSidedMaterials(gltf.scene);
+            this.ensureVertexNormals(gltf.scene);
+            this.tuneTextureSampling(gltf.scene);
+            this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation);
+            this.modelLoading$.next(false);
+        };
+        const onError = (error) => {
+            // Cancelling is a decision, not a failure: clear the overlay without an error in the console.
+            if (error?.name === 'AbortError') {
+                // Only a cancel of the load that is still current came from the user; anything else is this
+                // load having been superseded or discarded.
+                if (this.loadAbortController?.signal.aborted) {
+                    this.modelLoadCancelled$.next();
+                }
+            }
+            else {
+                console.error('Error loading GLTF model:', error);
+            }
+            this.modelLoading$.next(false);
+            this.modelLoadProgress$.next(null);
+        };
+        // GLTFLoader decodes embedded images with createImageBitmap when the browser offers it, and on
+        // large texture atlases that path returns visibly corrupt data - scattered white blocks across
+        // the model. The exact same bytes decoded through an HTMLImageElement, which is what the .obj
+        // path uses via MTLLoader, come out clean. GLTFLoader already falls back to that decoder for
+        // Safari and older Firefox; this simply extends the fallback to cover this case too.
+        //
+        // The decoder is chosen while GLTFParser is being constructed, which happens synchronously
+        // inside parse(), so hiding createImageBitmap only has to hold across that call rather than
+        // for the whole download.
+        this.fetchWithProgress(url, cacheKey)
+            // parse() holds the main thread for seconds on a large model. Yield until the browser has
+            // actually painted first, otherwise the final progress update never reaches the screen and
+            // the bar appears to stall short of the end.
+            .then((buffer) => this.afterNextPaint().then(() => buffer))
+            .then((buffer) => {
+            // parse() cannot be interrupted, so a cancel that lands during the paint yield has to be
+            // caught here - the last moment before the main thread is committed for several seconds.
+            if (this.loadAbortController?.signal.aborted) {
+                throw new DOMException('Model load cancelled', 'AbortError');
+            }
+            const globalScope = globalThis;
+            const originalCreateImageBitmap = globalScope.createImageBitmap;
+            globalScope.createImageBitmap = undefined;
+            try {
+                loader.parse(buffer, url.substring(0, url.lastIndexOf('/') + 1), onLoaded, onError);
+            }
+            finally {
+                globalScope.createImageBitmap = originalCreateImageBitmap;
+            }
+        })
+            .catch(onError);
+    }
+    /**
+     * Stops the model download in progress, if any.
+     *
+     * Only the download can be interrupted: parse() runs synchronously and holds the main thread until
+     * it finishes, so once it has begun there is nothing to cancel. In practice the download is the
+     * long part, which is where someone reaches for this.
+     */
+    cancelModelLoad() {
+        this.loadAbortController?.abort();
+    }
+    /**
+     * Abandons the load in progress without reporting it as cancelled.
+     *
+     * Dropping the controller is what makes the difference: onError treats an abort as user-initiated
+     * only while the controller that aborted is still the current one. Tearing down or rebuilding the
+     * scene is not something the person asked for, so it must not surface as "loading cancelled".
+     */
+    discardCurrentLoad() {
+        this.loadAbortController?.abort();
+        this.loadAbortController = undefined;
+    }
+    /**
+     * Resolves once the browser has painted at least one frame.
+     *
+     * A requestAnimationFrame callback runs *before* that frame is painted, so a single one is not
+     * enough to guarantee pending DOM changes are on screen; the second fires after the first frame
+     * has gone out. Falls back to a timeout where rAF isn't available (SSR, tests).
+     */
+    afterNextPaint() {
+        if (typeof requestAnimationFrame !== 'function') {
+            return new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        return new Promise((resolve) => {
+            requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+        });
+    }
+    /**
+     * Downloads a file, reporting progress on modelLoadProgress$ as it arrives.
+     *
+     * GLTFLoader.load() would report progress through XHR, but this path deliberately uses fetch() +
+     * parse() instead (see loadGLTFModel for why), so progress is read off the response stream here.
+     * That is also the more useful number: on a model of this size the download dominates, and the
+     * stream reports it as it happens rather than in one jump at the end.
+     */
+    async fetchWithProgress(url, cacheKey) {
+        // A load already running is replaced, not raced: whichever finished last would otherwise win.
+        this.loadAbortController?.abort();
+        this.loadAbortController = new AbortController();
+        const { signal } = this.loadAbortController;
+        const cached = await this.readModelFromCache(cacheKey);
+        if (cached) {
+            this.modelLoadProgress$.next(1);
+            return cached;
+        }
+        const response = await fetch(url, { signal });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+        }
+        const contentLength = Number(response.headers.get('Content-Length'));
+        const total = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : 0;
+        // Without a readable stream (older browsers, some polyfills) there is nothing to measure, so
+        // fall back to a plain buffered read and let the UI show an indeterminate indicator.
+        if (!response.body?.getReader) {
+            this.modelLoadProgress$.next(null);
+            return response.arrayBuffer();
+        }
+        const reader = response.body.getReader();
+        // With a known size, write chunks straight into one pre-allocated buffer. Collecting them in an
+        // array and concatenating afterwards would hold both copies at once - on a 164 MB model that is
+        // an avoidable 300+ MB peak.
+        const buffer = total > 0 ? new Uint8Array(total) : null;
+        const chunks = [];
+        let usingBuffer = buffer !== null;
+        let received = 0;
+        // Chunks arrive in tens of kilobytes, so a 164 MB model produces thousands of them. Emitting on
+        // every one would run change detection just as often to move a bar that is measured in whole
+        // percent, so only report when the displayed value would actually change.
+        let lastReported = -1;
+        if (total === 0) {
+            this.modelLoadProgress$.next(null);
+        }
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            if (signal.aborted) {
+                // Free the connection rather than leaving it draining in the background.
+                await reader.cancel();
+                throw new DOMException('Model load cancelled', 'AbortError');
+            }
+            if (usingBuffer && received + value.length > total) {
+                // Content-Length understated the real size. Move what we have into the chunk list and stay
+                // there for the rest of the response, rather than truncating the tail.
+                chunks.push(buffer.slice(0, received));
+                usingBuffer = false;
+            }
+            if (usingBuffer) {
+                buffer.set(value, received);
+            }
+            else {
+                chunks.push(value);
+            }
+            received += value.length;
+            if (total > 0) {
+                const percent = Math.min(Math.round((received / total) * 100), 100);
+                if (percent !== lastReported) {
+                    lastReported = percent;
+                    this.modelLoadProgress$.next(percent / 100);
+                }
+            }
+        }
+        // The stream can end below the advertised size (or with no size at all). Land on a full bar
+        // rather than leaving it stuck at whatever the last chunk happened to reach.
+        if (total > 0 && lastReported !== 100) {
+            this.modelLoadProgress$.next(1);
+        }
+        let result;
+        if (usingBuffer && received === total) {
+            result = buffer.buffer;
+        }
+        else if (usingBuffer) {
+            // Fewer bytes than advertised: hand back exactly what arrived.
+            result = buffer.buffer.slice(0, received);
+        }
+        else {
+            const merged = new Uint8Array(received);
+            let offset = 0;
+            chunks.forEach((chunk) => {
+                merged.set(chunk, offset);
+                offset += chunk.length;
+            });
+            result = merged.buffer;
+        }
+        await this.writeModelToCache(cacheKey, result);
+        return result;
+    }
+    /**
+     * The model store, or null where the browser will not give us one.
+     *
+     * Cache Storage needs a secure context, so it is absent over plain http and in some embedded
+     * webviews. Every caller treats that as a miss - caching is an optimisation, never a requirement.
+     */
+    async openModelCache() {
+        if (typeof caches === 'undefined') {
+            return null;
+        }
+        try {
+            return await caches.open(ThreeJsService.MODEL_CACHE);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * A cached copy of this model, if one was stored.
+     *
+     * Keyed by the S3 key rather than the URL it is fetched from: that URL is signed, so it carries a
+     * fresh signature and expiry every time and would never match twice. The browser's own HTTP cache
+     * misses for the same reason, which is why this exists at all.
+     */
+    async readModelFromCache(cacheKey) {
+        if (!cacheKey) {
+            return null;
+        }
+        try {
+            const cache = await this.openModelCache();
+            const hit = await cache?.match(this.modelCacheUrl(cacheKey));
+            return hit ? await hit.arrayBuffer() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Stores a model for next time, evicting the oldest once a few are held. */
+    async writeModelToCache(cacheKey, model) {
+        if (!cacheKey) {
+            return;
+        }
+        try {
+            const cache = await this.openModelCache();
+            if (!cache) {
+                return;
+            }
+            await cache.put(this.modelCacheUrl(cacheKey), new Response(model));
+            // Models run to hundreds of megabytes, so this cannot grow without limit. Cache Storage keeps
+            // insertion order, which makes the front of the list the least recently stored.
+            const keys = await cache.keys();
+            await Promise.all(keys.slice(0, Math.max(0, keys.length - ThreeJsService.MODEL_CACHE_SIZE))
+                .map((key) => cache.delete(key)));
+        }
+        catch {
+            // Out of quota, private browsing, storage disabled: the model is already loaded either way.
+        }
+    }
+    /** Cache Storage keys on a URL, so the S3 key is expressed as one. It is never requested. */
+    modelCacheUrl(cacheKey) {
+        return `https://3d-model-cache.smarterplan.local/${encodeURIComponent(cacheKey)}`;
+    }
+    /**
+     * Fits the camera's clipping planes to how big the model actually is.
+     *
+     * Depth precision depends on the far/near ratio, and the fixed 0.1 / 10000 the camera starts with
+     * is a ratio of 100000 for a model only ~10 units across. That wastes most of the depth buffer on
+     * empty space and lets nearly coincident surfaces - which captured meshes have everywhere -
+     * flicker against each other.
+     */
+    adjustClippingPlanes(radius) {
+        if (radius < 10) {
+            this.camera.near = 0.01;
+            this.camera.far = 100;
+        }
+        else if (radius < 100) {
+            this.camera.near = 0.1;
+            this.camera.far = 1000;
+        }
+        else if (radius < 1000) {
+            this.camera.near = 10;
+            this.camera.far = 10000;
+        }
+        else {
+            this.camera.near = 100;
+            this.camera.far = 1000000;
+        }
+        this.camera.updateProjectionMatrix();
+    }
+    /**
+     * Swaps the PBR materials GLTFLoader builds for the plain Phong ones the .obj path produces.
+     *
+     * MeshStandardMaterial keeps a specular reflection even at metalness 0, since every dielectric
+     * reflects some light, and Fresnel drives that reflection towards white as a surface turns away
+     * from the viewer. On an aerial view of a facade most surfaces sit at exactly those grazing
+     * angles, which paints white highlights over window frames and roof edges - the same model
+     * loaded as .obj never shows them, because MTLLoader builds Phong materials and OBJLoader zeroes
+     * their specular when the .mtl declares Ns 0.
+     *
+     * Captured models carry their lighting in the texture and want no specular response at all, so
+     * matching the .obj path here is both the fix and the more faithful choice.
+     */
+    convertToPhongMaterials(root) {
+        const converted = new Map();
+        root.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh) {
+                return;
+            }
+            const convert = (source) => {
+                if (!source || !source.isMeshStandardMaterial) {
+                    return source;
+                }
+                if (!converted.has(source)) {
+                    const phong = new THREE.MeshPhongMaterial({
+                        map: source.map,
+                        color: source.color,
+                        transparent: source.transparent,
+                        opacity: source.opacity,
+                        alphaTest: source.alphaTest,
+                        side: source.side,
+                        specular: new THREE.Color(0x000000),
+                        shininess: 0,
+                    });
+                    phong.name = source.name;
+                    converted.set(source, phong);
+                }
+                return converted.get(source);
+            };
+            mesh.material = Array.isArray(mesh.material)
+                ? mesh.material.map(convert)
+                : convert(mesh.material);
+        });
+    }
+    /**
+     * Renders every material double-sided.
+     *
+     * Reality capture meshes routinely contain triangles with reversed winding - an artefact of the
+     * reconstruction, not of the file. With the default FrontSide those triangles are culled, leaving
+     * scattered holes that show the scene background through the model. Against a light background
+     * they read as white specks with no discernible pattern.
+     *
+     * Drawing both sides costs a little fill rate but is what makes captured geometry render as
+     * solid; other viewers of this kind of content do the same unconditionally.
+     */
+    forceDoubleSidedMaterials(root) {
+        const seen = new Set();
+        root.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh) {
+                return;
+            }
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            materials.forEach((material) => {
+                if (material && !seen.has(material)) {
+                    seen.add(material);
+                    material.side = THREE.DoubleSide;
+                    material.needsUpdate = true;
+                }
+            });
+        });
+    }
+    /**
+     * Computes real vertex normals for any geometry that arrived without them.
+     *
+     * A glTF without a NORMAL attribute is spec-compliant, and GLTFLoader handles it by switching the
+     * material to flatShading, which makes the shader derive the normal per pixel from screen-space
+     * derivatives. That derivation collapses on the degenerate, needle-thin triangles that reality
+     * capture meshes are full of: the face has almost no area, the derived normal is meaningless, and
+     * lighting blows those fragments out to white specks - densest exactly where fine detail is.
+     *
+     * Computing normals from the geometry instead is robust to those triangles, since a degenerate
+     * face contributes almost nothing to the average and its neighbours dominate.
+     */
+    ensureVertexNormals(root) {
+        root.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh) {
+                return;
+            }
+            const geometry = mesh.geometry;
+            if (geometry.getAttribute('normal')) {
+                return;
+            }
+            geometry.computeVertexNormals();
+            // GLTFLoader already switched these materials to flatShading because normals were missing;
+            // now that real ones exist, let them be used instead of the derivative fallback.
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            materials.forEach((material) => {
+                if (material && material.flatShading) {
+                    material.flatShading = false;
+                    material.needsUpdate = true;
+                }
+            });
+        });
+    }
+    /**
+     * Configures how every texture in a model is sampled: maximum anisotropy, and no mipmapping.
+     *
+     * Photogrammetry atlases pack their UV islands with unused gutter pixels between them. Mipmapping
+     * averages neighbouring pixels at each level, so those gutters bleed further into the islands the
+     * smaller the level gets - and viewing the whole model at once uses the smallest levels, painting
+     * bright gutter pixels over the edges of fine detail. Sampling the full-resolution image avoids
+     * that, at the cost of some shimmer on minified surfaces.
+     *
+     * Note that anisotropy only takes effect while mipmapping is on, so with the settings below it is
+     * inert; it is set anyway so the sampling stays correct for anyone who re-enables mipmaps here.
+     */
+    tuneTextureSampling(root) {
+        if (!this.renderer) {
+            return;
+        }
+        const maxAnisotropy = this.renderer.capabilities.getMaxAnisotropy();
+        if (!maxAnisotropy || maxAnisotropy <= 1) {
+            return;
+        }
+        const seen = new Set();
+        root.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh) {
+                return;
+            }
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            materials.forEach((material) => {
+                if (!material) {
+                    return;
+                }
+                // Same texture is reused across the model's materials; only touch each one once.
+                ['map', 'normalMap', 'roughnessMap', 'metalnessMap', 'emissiveMap', 'aoMap'].forEach((slot) => {
+                    const texture = material[slot];
+                    if (texture && !seen.has(texture)) {
+                        seen.add(texture);
+                        texture.anisotropy = maxAnisotropy;
+                        texture.generateMipmaps = false;
+                        texture.minFilter = THREE.LinearFilter;
+                        texture.needsUpdate = true;
+                    }
+                });
+            });
+        });
+    }
+    /**
+     * Loads an OBJ model with MTL.
+     * The heavy text-parsing step runs in a Web Worker when one has been registered via
+     * setObjParserWorker (see there for why the app, not this library, provides it); this keeps
+     * the main thread free while large architecture models (millions of vertices) are parsed.
+     * Falls back to parsing on the main thread otherwise.
+     */
+    loadObjModel(mtlUrl, objUrl, cameraPosition, rotation) {
+        const mtlLoader = new MTLLoader();
+        const basePath = mtlUrl.substring(0, mtlUrl.lastIndexOf('/') + 1);
+        mtlLoader.setPath(basePath);
+        const mtlFileName = mtlUrl.substring(mtlUrl.lastIndexOf('/') + 1);
+        this.modelLoading$.next(true);
+        mtlLoader.load(mtlFileName, (materials) => {
+            materials.preload();
+            if (this.objParserWorker) {
+                this.requestObjParseInWorker(objUrl)
+                    .then((meshes) => {
+                    const group = new THREE.Group();
+                    meshes.forEach((meshData) => {
+                        group.add(this.meshFromParsedData(meshData, materials));
+                    });
+                    this.placeLoadedObjectInScene(group, cameraPosition, rotation);
+                })
+                    .catch((error) => {
+                    console.error('Error parsing OBJ model in worker:', error);
+                })
+                    .finally(() => this.modelLoading$.next(false));
+                return;
+            }
+            const objLoader = new OBJLoader();
+            objLoader.setMaterials(materials);
+            objLoader.load(objUrl, (object) => {
+                this.placeLoadedObjectInScene(object, cameraPosition, rotation);
+                this.modelLoading$.next(false);
+            }, undefined, (error) => {
+                console.error('Error loading OBJ model:', error);
+                this.modelLoading$.next(false);
+            });
+        }, undefined, (error) => {
+            console.error('Error loading MTL file:', error);
+            this.modelLoading$.next(false);
+        });
+    }
+    /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */
+    placeLoadedObjectInScene(object, cameraPosition, rotation) {
+        const box = new THREE.Box3().setFromObject(object);
+        const center = box.getCenter(new THREE.Vector3());
+        const size = box.getSize(new THREE.Vector3());
+        const maxDim = Math.max(size.x, size.y, size.z);
+        const scale = maxDim > 0 ? 10 / maxDim : 1;
+        // Two nested groups so tags can share the model's frame: `centered` carries the offset that
+        // moves the model's own origin to the scene origin, `group` carries the scale. A tag positioned
+        // with raw POI coordinates then lands in the same place the model's geometry does.
+        const group = new THREE.Group();
+        const centered = new THREE.Group();
+        centered.position.sub(center);
+        if (rotation) {
+            object.rotation.set(rotation.x, rotation.y, rotation.z);
+        }
+        this.modelRoot = object;
+        // 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);
+        group.add(centered);
+        group.scale.setScalar(scale);
+        this.scene.add(group);
+        // Tags registered before the model finished loading were sized against the old scale.
+        this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));
+        this.adjustClippingPlanes((size.length() / 2) * scale);
+        if (cameraPosition) {
+            this.camera.position.set(cameraPosition.x, cameraPosition.y, cameraPosition.z);
+        }
+        else {
+            this.camera.position.set(0, 5, 15);
+        }
+        this.controls.target.set(0, 0, 0);
+        this.controls.update();
+    }
+    /**
+     * Keeps the drawing buffer and camera matched to the canvas as it is resized.
+     *
+     * renderer.setSize() writes explicit pixel width/height into the canvas's style, overriding the
+     * 100%/100% it starts with. Without this, the canvas keeps whatever size it had at startup: hiding
+     * the top menu grows the container, the canvas does not follow, and the strip that opens up shows
+     * the page behind it instead of the scene.
+     *
+     * The parent is observed rather than the canvas, because resizing the canvas is what this reacts
+     * to - watching the element we resize would retrigger the observer.
+     */
+    observeCanvasResize(canvas) {
+        const container = canvas.parentElement;
+        if (!container || typeof ResizeObserver === 'undefined') {
+            return;
+        }
+        this.canvasResizeObserver = new ResizeObserver(() => {
+            const width = container.clientWidth;
+            const height = container.clientHeight;
+            if (width === 0 || height === 0) {
+                return;
+            }
+            this.camera.aspect = width / height;
+            this.camera.updateProjectionMatrix();
+            this.renderer.setSize(width, height);
+        });
+        this.canvasResizeObserver.observe(container);
+    }
+    /**
+     * Starts the alignment walkthrough: pick a tag, then click where it really is, three times.
+     *
+     * Existing tags are the correspondences - they already carry the stored coordinate, so the person
+     * only has to supply the matching spot on the model. No new records are written; nothing is
+     * applied until solveAlignmentFromPairs() succeeds.
+     */
+    startTagAlignment() {
+        this.aligning = true;
+        this.alignmentPairs = [];
+        this.alignmentSource = null;
+        if (this.renderer) {
+            this.renderer.domElement.style.cursor = 'crosshair';
+        }
+        this.alignmentProgress$.next({ pairs: 0, awaiting: 'tag' });
+    }
+    cancelTagAlignment() {
+        const wasAligning = this.aligning;
+        this.aligning = false;
+        this.alignmentPairs = [];
+        this.alignmentSource = null;
+        this.pendingPreviewEvent = null;
+        this.removePlacementPreview();
+        if (this.renderer) {
+            this.renderer.domElement.style.cursor = 'default';
+        }
+        this.alignmentProgress$.next({ pairs: 0, awaiting: null });
+        if (wasAligning) {
+            this.alignmentCancelled$.next();
+        }
+    }
+    isAligningTags() {
+        return this.aligning;
+    }
+    /**
+     * Whether the pointer should be showing the placement ghost.
+     *
+     * True while placing a tag, and while calibrating once a tag has been picked - that second click
+     * is the same question ("where on the model?") and deserves the same aiming aid. Not true for the
+     * first half of a pair, which is a click on a tag, not on the model.
+     */
+    isPreviewingPlacement() {
+        return this.placingTag || (this.aligning && !!this.alignmentSource);
+    }
+    /** Whether a tag is currently registered for this element. */
+    hasTag(elementId) {
+        return this.tagSprites.has(elementId);
+    }
+    /**
+     * Solves and applies the alignment collected so far, returning it so the caller can persist it.
+     *
+     * Returns null when the three tags turn out to be collinear, in which case nothing is applied and
+     * the walkthrough stays open for the person to pick a better third point.
+     */
+    solveAlignmentFromPairs() {
+        const alignment = solveThreeJsAlignment(this.alignmentPairs);
+        if (!alignment) {
+            return null;
+        }
+        this.setTagAlignment(alignment);
+        this.aligning = false;
+        this.pendingPreviewEvent = null;
+        this.removePlacementPreview();
+        this.renderer.domElement.style.cursor = 'default';
+        this.alignmentProgress$.next({ pairs: this.alignmentPairs.length, awaiting: null });
+        return alignment;
+    }
+    /** 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];
+            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,
+            });
+            return;
+        }
+        // Second half: where that tag actually belongs on the model.
+        const target = this.pickAlignmentTarget(event);
+        if (!target) {
+            return;
+        }
+        this.alignmentPairs.push({ 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',
+        });
+    }
+    /** 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.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);
+    }
+    /**
+     * 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,
+            });
+        }
+        const rect = this.renderer.domElement.getBoundingClientRect();
+        const x = event.clientX - rect.left;
+        const y = event.clientY - rect.top;
+        if (x < 0 || y < 0 || x > rect.width || y > rect.height) {
+            return null;
+        }
+        this.pickCamera.copy(this.camera);
+        this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);
+        // Renders the one pixel the cursor is over as if it were the whole image - offset by half a
+        // pixel so the cursor sits at that pixel's centre, which is where NDC (0, 0) lands.
+        this.pickCamera.setViewOffset(rect.width, rect.height, x - 0.5, y - 0.5, 1, 1);
+        // Where the model is not, the pixel must read as "nothing", so it is cleared to white - a value
+        // no real depth packs to. Two things would otherwise paint over that: the default black clear,
+        // which decodes as depth 0 (a hit against the lens), and the scene background, which three.js
+        // draws in place of the clear colour whenever one is set.
+        const previousClearColor = this.renderer.getClearColor(new THREE.Color());
+        const previousClearAlpha = this.renderer.getClearAlpha();
+        const previousTarget = this.renderer.getRenderTarget();
+        const previousBackground = this.scene.background;
+        this.scene.background = null;
+        this.scene.overrideMaterial = this.pickDepthMaterial;
+        this.renderer.setClearColor(0xffffff, 1);
+        this.renderer.setRenderTarget(this.pickTarget);
+        this.renderer.clear();
+        this.renderer.render(this.scene, this.pickCamera);
+        this.renderer.readRenderTargetPixels(this.pickTarget, 0, 0, 1, 1, this.pickPixel);
+        this.renderer.setRenderTarget(previousTarget);
+        this.renderer.setClearColor(previousClearColor, previousClearAlpha);
+        this.scene.overrideMaterial = null;
+        this.scene.background = previousBackground;
+        const [r, g, b, a] = this.pickPixel;
+        if (r === 255 && g === 255 && b === 255 && a === 255) {
+            return null;
+        }
+        // The inverse of three's packDepthToRGBA, which stores the value itself in alpha and ever finer
+        // fractions of it in blue, green and red - alpha is the most significant byte, not red. Read the
+        // other way round, the result is mostly the low-order noise, often near zero, which unprojects
+        // onto the near plane: a ghost pressed against the lens, filling the whole screen.
+        const downscale = 255 / 256;
+        const depth = (r / 255) * downscale / (256 * 256 * 256) +
+            (g / 255) * downscale / (256 * 256) +
+            (b / 255) * downscale / 256 +
+            (a / 255) * downscale;
+        // NDC x and y are zero because the pixel read is the centre of that one-pixel image - which only
+        // holds while the view offset is in effect. Clearing it first would unproject through the full
+        // view instead, landing the point on the ray through the middle of the screen. The offset is
+        // simply replaced by the next pick, so it is never cleared.
+        const world = new THREE.Vector3(0, 0, depth * 2 - 1).unproject(this.pickCamera);
+        this.tagGroup.updateWorldMatrix(true, false);
+        return this.tagGroup.worldToLocal(world);
+    }
+    removePlacementPreview() {
+        if (!this.placementPreview) {
+            return;
+        }
+        this.tagGroup.remove(this.placementPreview);
+        this.placementPreview.material.map?.dispose();
+        this.placementPreview.material.dispose();
+        this.placementPreview = undefined;
+    }
+    /** Shows or hides one tag, leaving it registered so it can be brought back without reloading. */
+    setTagVisibility(elementId, visible) {
+        const sprite = this.tagSprites.get(elementId);
+        if (sprite) {
+            sprite.visible = visible;
+        }
+    }
+    /**
+     * Shows only tags of the given types, hiding the rest.
+     *
+     * Passing null shows everything - the "no filter" state, distinct from an empty array, which is a
+     * filter that happens to match nothing.
+     */
+    setVisibleTagTypes(types) {
+        this.tagSprites.forEach((sprite) => {
+            sprite.visible = types === null || types.includes(sprite.userData.poiType);
+        });
+    }
+    /**
+     * Moves the camera to look at a tag, mirroring Matterport's goToTag.
+     *
+     * Animated rather than teleported: jumping the camera loses the viewer's sense of where they were
+     * relative to the model. The approach distance follows the model's size so it frames sensibly
+     * whatever the units are.
+     */
+    goToTag(elementId) {
+        const sprite = this.tagSprites.get(elementId);
+        if (!sprite || !this.camera) {
+            return;
+        }
+        const target = sprite.getWorldPosition(new THREE.Vector3());
+        const distance = this.modelRoot
+            ? new THREE.Box3().setFromObject(this.modelRoot).getSize(new THREE.Vector3()).length() * 0.15
+            : 5;
+        // Approach along the current viewing direction, so the camera closes in rather than swinging
+        // around to an arbitrary side.
+        const direction = this.camera.position.clone().sub(this.controls.target).normalize();
+        this.cameraTween = {
+            fromPosition: this.camera.position.clone(),
+            toPosition: target.clone().add(direction.multiplyScalar(distance)),
+            fromTarget: this.controls.target.clone(),
+            toTarget: target,
+            startedAt: performance.now(),
+            durationMs: 600,
+        };
+    }
+    /** Advances the camera animation started by goToTag, if one is running. */
+    stepCameraTween() {
+        if (!this.cameraTween) {
+            return;
+        }
+        const { fromPosition, toPosition, fromTarget, toTarget, startedAt, durationMs } = this.cameraTween;
+        const linear = Math.min((performance.now() - startedAt) / durationMs, 1);
+        // Ease out, so the move settles instead of stopping dead.
+        const t = 1 - Math.pow(1 - linear, 3);
+        this.camera.position.lerpVectors(fromPosition, toPosition, t);
+        this.controls.target.lerpVectors(fromTarget, toTarget, t);
+        if (linear >= 1) {
+            this.cameraTween = null;
+        }
+    }
+    isPlacingTag() {
+        return this.placingTag;
+    }
+    /** The spot picked by the last placement, for whoever commits it to a POI. */
+    getPendingTagPlacement() {
+        return this.pendingTagPlacement;
+    }
+    /**
+     * Raycasts a click against the model's geometry and returns the hit, in world space.
+     *
+     * Returns null when the click missed, which is a normal outcome - the user clicked the sky - and
+     * leaves whatever mode is armed still armed, so they can simply try again.
+     */
+    raycastModel(event) {
+        if (!this.modelRoot) {
+            return null;
+        }
+        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;
+        this.raycaster.setFromCamera(this.mouse, this.camera);
+        return this.raycaster.intersectObject(this.modelRoot, true)[0] ?? null;
+    }
+    /**
+     * Turns a click into a point on the model, in the frame tag coordinates are persisted in.
+     *
+     * That frame is the tag group's, not the model's. A stored coordinate is read back as a sprite
+     * position inside that group, so a coordinate captured in any other frame comes back displaced by
+     * exactly however far the alignment moves the group. The two frames agree only while the
+     * alignment is identity, which is why this stayed invisible until a model was calibrated.
+     */
+    pickPlacementOnModel(event) {
+        const hit = this.raycastModel(event);
+        if (!hit) {
+            return null;
+        }
+        this.tagGroup.updateWorldMatrix(true, false);
+        const position = this.tagGroup.worldToLocal(hit.point.clone());
+        // A face normal is in the geometry's local space already, but the mesh it belongs to may sit
+        // under transforms of its own, so take it out through those and back into the tag frame, so it
+        // describes the same orientation the position does.
+        let normal = new THREE.Vector3(0, 1, 0);
+        if (hit.face) {
+            normal = hit.face.normal
+                .clone()
+                .transformDirection(hit.object.matrixWorld)
+                .transformDirection(new THREE.Matrix4().copy(this.tagGroup.matrixWorld).invert())
+                .normalize();
+        }
+        return {
+            position: { x: position.x, y: position.y, z: position.z },
+            normal: { x: normal.x, y: normal.y, z: normal.z },
+        };
+    }
+    /**
+     * Where the user says a tag really belongs, in the space the solved alignment maps onto.
+     *
+     * setTagAlignment writes the solution to the tag group's own transform, which is expressed
+     * relative to its parent - so the target has to be in the parent's frame. Measuring it in the
+     * group's own frame instead would fold the current alignment into the answer, making each
+     * calibration depend on the one before it.
+     */
+    pickAlignmentTarget(event) {
+        const hit = this.raycastModel(event);
+        if (!hit) {
+            return null;
+        }
+        const frame = this.tagGroup.parent ?? this.scene;
+        frame.updateWorldMatrix(true, false);
+        const point = frame.worldToLocal(hit.point.clone());
+        return { x: point.x, y: point.y, z: point.z };
+    }
+    /**
+     * Sets the transform mapping captured tag coordinates onto this model's space.
+     *
+     * Every tag comes from the same source space, so this is one transform on the group rather than
+     * per-tag maths - which also means it applies retroactively to tags already placed, and can be
+     * adjusted live while someone dials the numbers in.
+     *
+     * Passing null resets to identity, i.e. tag coordinates are already in model space.
+     */
+    setTagAlignment(alignment) {
+        const { translation, rotation, scale } = alignment ?? {};
+        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.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));
+    }
+    /**
+     * Adds a tag, or moves/restyles the one already registered for this element.
+     *
+     * Upsert rather than a declarative "here is the full list" call, because tags arrive per type
+     * (equipment, then tickets, then measurements...) from separate subscriptions - replacing the set
+     * on each of those would wipe the types that came before.
+     */
+    upsertTag(tag) {
+        const existing = this.tagSprites.get(tag.id);
+        if (existing) {
+            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;
+            return;
+        }
+        const sprite = new THREE.Sprite(new THREE.SpriteMaterial({
+            map: this.createTagTexture(tag.color),
+            // Tags read as UI rather than geometry, so they stay visible through the model instead of
+            // being occluded by whatever wall happens to be between them and the camera.
+            depthTest: false,
+            transparent: true,
+        }));
+        sprite.name = tag.id;
+        sprite.userData.poiType = tag.poiType ?? null;
+        sprite.userData.label = tag.label ?? null;
+        sprite.position.set(tag.position.x, tag.position.y, tag.position.z);
+        sprite.renderOrder = 999;
+        this.scaleTagForModel(sprite);
+        this.tagGroup.add(sprite);
+        this.tagSprites.set(tag.id, sprite);
+        if (tag.iconUrl) {
+            this.applyTagIcon(sprite, tag.iconUrl);
+        }
+    }
+    /** Removes the tag registered for an element, if there is one. */
+    removeTag(elementId) {
+        const sprite = this.tagSprites.get(elementId);
+        if (!sprite) {
+            return;
+        }
+        this.tagGroup.remove(sprite);
+        sprite.material.map?.dispose();
+        sprite.material.dispose();
+        this.tagSprites.delete(elementId);
+    }
+    /** Removes every tag from the scene. */
+    clearTags() {
+        [...this.tagSprites.keys()].forEach((id) => this.removeTag(id));
+    }
+    /** Loads an icon into an existing tag, leaving the fallback disc in place if it fails. */
+    applyTagIcon(sprite, iconUrl) {
+        new THREE.TextureLoader().load(iconUrl, (texture) => {
+            sprite.material.map?.dispose();
+            sprite.material.map = texture;
+            sprite.material.needsUpdate = true;
+        }, undefined, () => console.warn(`ThreeJsService: could not load tag icon "${iconUrl}", keeping the default marker.`));
+    }
+    /** Draws the default tag marker: a filled disc with a white ring, so it reads on any background. */
+    createTagTexture(color = '#1E88E5') {
+        const size = 128;
+        const canvas = document.createElement('canvas');
+        canvas.width = size;
+        canvas.height = size;
+        const context = canvas.getContext('2d');
+        context.beginPath();
+        context.arc(size / 2, size / 2, size / 2 - 8, 0, Math.PI * 2);
+        context.fillStyle = color;
+        context.fill();
+        context.lineWidth = 8;
+        context.strokeStyle = '#FFFFFF';
+        context.stroke();
+        return new THREE.CanvasTexture(canvas);
+    }
+    /**
+     * Sizes a tag relative to the model.
+     *
+     * A sprite inherits the model's scale and the alignment's, so a fixed size would come out tiny on
+     * a large model and huge on a small one. Dividing by the group's world scale keeps tags the same
+     * size on screen whatever the model's units are.
+     */
+    scaleTagForModel(sprite) {
+        const worldScale = this.tagGroup.getWorldScale(new THREE.Vector3()).x || 1;
+        const size = 0.4 / worldScale;
+        sprite.scale.set(size, size, 1);
+    }
+    /**
+     * Adds secondary interactive objects (e.g., POIs, sensors) to the scene.
+     */
+    updateObjsToScene(objsAdded) {
+        const existingIds = this.clickableObjects.map((obj) => obj.name);
+        const objLoader = new OBJLoader();
+        // delete objects that are not in the provided array
+        this.clickableObjects.forEach((obj) => {
+            if (!objsAdded.find((objData) => objData.id === obj.name)) {
+                this.scene.remove(obj);
+                this.clickableObjects = this.clickableObjects.filter((object) => object.name !== obj.name);
+            }
+        });
+        objsAdded.forEach((objectData) => {
+            if (!existingIds.includes(objectData.id)) {
+                objLoader.load(objectData.file, (newObject) => {
+                    newObject.name = objectData.id;
+                    newObject.traverse((child) => {
+                        if (child.isMesh) {
+                            const mesh = child;
+                            if (mesh.material instanceof THREE.Material) {
+                                mesh.material.transparent = true;
+                                mesh.material.opacity = 0.8;
+                            }
+                        }
+                    });
+                    // set object position and rotation
+                    newObject.position.set(objectData.position.x, objectData.position.y, objectData.position.z);
+                    // The JSON configuration has rotation already in radians (e.g. 3.1415...)
+                    newObject.rotation.set(objectData.rotation.x, objectData.rotation.y, objectData.rotation.z);
+                    newObject.scale.set(objectData.scale.x, objectData.scale.y, objectData.scale.z);
+                    this.scene.add(newObject);
+                    this.clickableObjects.push(newObject);
+                });
+            }
+        });
+    }
+    onMouseMove(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;
+            this.raycaster.setFromCamera(this.mouse, this.camera);
+            // While the ghost is up it follows the pointer and nothing else should react to it. The move
+            // is only recorded here: pointer events fire far more often than frames, and picking a point
+            // costs a raycast against the whole model, so doing it per event is what made the ghost trail
+            // behind the cursor. The render loop picks up the latest position, once, per frame.
+            if (this.isPreviewingPlacement()) {
+                this.pendingPreviewEvent = event;
+                return;
+            }
+            // Not previewing any more (a pair was just completed, say): drop a ghost left over from it.
+            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)
+                .find((hit) => hit.object.visible)?.object;
+            if (hoveredTag) {
+                this.renderer.domElement.style.cursor = 'pointer';
+                this.objectHovered$.next(null);
+                const label = hoveredTag.userData.label;
+                this.tagHovered$.next(label ? { label, event } : null);
+                return;
+            }
+            this.tagHovered$.next(null);
+            const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);
+            if (intersects.length > 0) {
+                this.renderer.domElement.style.cursor = 'pointer';
+                const intersectedObjectId = intersects[0].object?.parent?.name;
+                if (intersectedObjectId) {
+                    this.objectHovered$.next({ id: intersectedObjectId, event });
+                }
+            }
+            else {
+                this.renderer.domElement.style.cursor = 'default';
+                this.objectHovered$.next(null);
+            }
+        }
+        else {
+            this.renderer.domElement.style.cursor = 'grabbing';
+            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);
+            }
+        }
+    }
+    /**
+     * 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.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();
+        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 }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"threejs.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/threejs.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport * as THREE from 'three';\nimport { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';\nimport { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader';\nimport { MTLLoader } from 'three/examples/jsm/loaders/MTLLoader';\nimport { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';\nimport { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader';\nimport { MeshoptDecoder } from 'three/examples/jsm/libs/meshopt_decoder.module.js';\nimport { Subject } from 'rxjs';\nimport { ThreeJsAlignment } from '../helpers.service';\nimport { PoiType } from '../types.service';\n\n/**\n * A tag to draw in the Three.js scene, mirroring a Mattertag.\n *\n * Positions are in the model's own coordinate space - the same numbers stored in POI.coordinate -\n * not scene space. The service reparents tags under the model so they inherit the centering and\n * scaling applied at load, which means callers never deal with that transform.\n */\nexport interface ThreeJsTag {\n  /** The tagged element's id (POI.elementID), used to update or remove the tag later. */\n  id: string;\n  position: { x: number; y: number; z: number };\n  /** Drives both the click route and type filtering, so it travels with the tag. */\n  poiType?: PoiType | null;\n  /** Shown on hover. A marker with no identity is just a dot on a wall. */\n  label?: string | null;\n  /** Icon drawn on the tag. Falls back to a plain disc when absent or it fails to load. */\n  iconUrl?: string | null;\n  /** Tint for the fallback disc, as a CSS colour. */\n  color?: string;\n}\n\n/** What a click on a tag reports: enough to route to the element's detail page. */\nexport interface ThreeJsTagClick {\n  elementId: string;\n  poiType: PoiType | null;\n}\n\n/**\n * A spot picked on the model for a new tag.\n *\n * Both vectors are in the model's own coordinate space, which is what POI.coordinate stores. Scene\n * coordinates deliberately never leave this service: the model is scaled to a fixed size on load, so\n * a scene-space position would silently mean somewhere else the moment the .glb is re-exported.\n */\nexport interface ThreeJsTagPlacement {\n  position: { x: number; y: number; z: number };\n  /** Surface normal at the picked point - Matterport stores the same thing in POI.metadata. */\n  normal: { x: number; y: number; z: number };\n  /** What the placement was armed for, so the caller knows which creation form to open. */\n  poiType?: PoiType | null;\n}\n\n/** One tag seen in both spaces: where it is stored, and where it really sits on the model. */\nexport interface ThreeJsAlignmentPair {\n  source: { x: number; y: number; z: number };\n  target: { x: number; y: number; z: number };\n}\n\n/**\n * Builds an orthonormal frame from three points, or null when they are (nearly) collinear.\n *\n * Three points define a plane, and a plane plus an origin defines an orientation. Collinear points\n * do not: they leave the rotation about their common line undetermined, which is why the caller has\n * to reject them rather than produce a confident wrong answer.\n */\nfunction frameFromPoints(a: THREE.Vector3, b: THREE.Vector3, c: THREE.Vector3): THREE.Matrix4 | null {\n  const e1 = b.clone().sub(a);\n  if (e1.lengthSq() < 1e-12) {\n    return null;\n  }\n  e1.normalize();\n\n  const toC = c.clone().sub(a);\n  const e2 = toC.clone().sub(e1.clone().multiplyScalar(toC.dot(e1)));\n  if (e2.lengthSq() < 1e-12) {\n    return null;\n  }\n  e2.normalize();\n\n  return new THREE.Matrix4().makeBasis(e1, e2, e1.clone().cross(e2));\n}\n\n/**\n * Solves the transform that maps stored tag coordinates onto the loaded model.\n *\n * Takes exactly the correspondences a person can produce by hand: three tags, each pointed at twice\n * - once where it currently sits, once where it belongs. That is the minimum that pins down all\n * three parts of the answer. One pair fixes only translation; two leave the rotation about the line\n * between them free; three resolve it.\n *\n * Returns null when the points are collinear or degenerate, because a wrong alignment applied\n * silently is worse than none.\n */\nexport function solveThreeJsAlignment(pairs: ThreeJsAlignmentPair[]): ThreeJsAlignment | null {\n  if (!pairs || pairs.length < 3) {\n    return null;\n  }\n\n  const sources = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.source.x, pair.source.y, pair.source.z));\n  const targets = pairs.slice(0, 3).map((pair) => new THREE.Vector3(pair.target.x, pair.target.y, pair.target.z));\n\n  const sourceFrame = frameFromPoints(sources[0], sources[1], sources[2]);\n  const targetFrame = frameFromPoints(targets[0], targets[1], targets[2]);\n  if (!sourceFrame || !targetFrame) {\n    return null;\n  }\n\n  // A rotation's inverse is its transpose, so this is the rotation carrying one frame onto the other.\n  const rotation = targetFrame.multiply(sourceFrame.clone().transpose());\n\n  // Scale from how far apart the points are in each space, averaged over the three edges so a single\n  // sloppy click does not set it on its own.\n  const edges = [[0, 1], [1, 2], [0, 2]];\n  let ratioSum = 0;\n  let ratioCount = 0;\n  for (const [i, j] of edges) {\n    const sourceLength = sources[i].distanceTo(sources[j]);\n    const targetLength = targets[i].distanceTo(targets[j]);\n    if (sourceLength > 1e-9) {\n      ratioSum += targetLength / sourceLength;\n      ratioCount += 1;\n    }\n  }\n  if (ratioCount === 0) {\n    return null;\n  }\n  const scale = ratioSum / ratioCount;\n\n  // The group applies position, then rotation, then scale, so a point lands at t + s*R*p. Solving\n  // that for t at the centroids gives the translation.\n  const sourceCentroid = sources.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);\n  const targetCentroid = targets.reduce((sum, v) => sum.add(v), new THREE.Vector3()).multiplyScalar(1 / 3);\n  const translation = targetCentroid\n    .clone()\n    .sub(sourceCentroid.clone().applyMatrix4(rotation).multiplyScalar(scale));\n\n  const euler = new THREE.Euler().setFromRotationMatrix(rotation);\n\n  return {\n    translation: { x: translation.x, y: translation.y, z: translation.z },\n    rotation: { x: euler.x, y: euler.y, z: euler.z },\n    scale,\n  };\n}\n\nexport interface ObjAdded {\n  id: string;\n  name: string;\n  file: string; // The URL to the .obj file\n  position: { x: number; y: number; z: number };\n  rotation: { x: number; y: number; z: number };\n  scale: { x: number; y: number; z: number };\n}\n\ninterface ParsedMeshGroup {\n  start: number;\n  count: number;\n  materialIndex: number;\n}\n\n/** Raw geometry data extracted from a parsed OBJ mesh, sent back by the parser worker. */\ninterface ParsedMeshData {\n  name: string;\n  // One name per material used by this mesh. A single-material mesh has one entry;\n  // a mesh with multiple usemtl switches (geometry.groups) has one per group.\n  materialNames: string[];\n  groups: ParsedMeshGroup[] | null;\n  position: Float32Array;\n  normal: Float32Array | null;\n  uv: Float32Array | null;\n  index: Uint32Array | null;\n  boundingBox?: { min: [number, number, number]; max: [number, number, number] };\n}\n\ninterface ObjParserWorkerResponse {\n  requestId: string;\n  success: boolean;\n  meshes?: ParsedMeshData[];\n  error?: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ThreeJsService {\n  private scene!: THREE.Scene;\n  private camera!: THREE.PerspectiveCamera;\n  private renderer!: THREE.WebGLRenderer;\n  private controls!: OrbitControls;\n  private animationFrameId!: number;\n\n  // Raycasting and interaction\n  private raycaster = new THREE.Raycaster();\n  private mouse = new THREE.Vector2();\n  private isDraggingCamera: boolean = false;\n  private isDraggingTimer: any;\n  private clickableObjects: THREE.Object3D[] = [];\n\n  // Observables for the viewer component\n  public objectHovered$ = new Subject<{ id: string; event: MouseEvent } | null>();\n  public objectClicked$ = new Subject<string | null>();\n\n  /** Emits when the user clicks a tag, mirroring Matterport's tag click. */\n  public tagClicked$ = new Subject<ThreeJsTagClick>();\n\n  /** Emits a tag's label while the pointer is over it, and null when it leaves. */\n  public tagHovered$ = new Subject<{ label: string; event: MouseEvent } | null>();\n\n  // Tags live under the model rather than the scene, so the centering and scaling applied when the\n  // model is placed carries over and POI coordinates can stay in the model's own space.\n  private tagGroup = new THREE.Group();\n  private tagSprites = new Map<string, THREE.Sprite>();\n\n  private canvasResizeObserver?: ResizeObserver;\n\n  /** Aborts the in-flight model download. Parsing cannot be interrupted, only not started. */\n  private loadAbortController?: AbortController;\n\n  // The loaded base model, kept so tag placement can raycast against its geometry.\n  private modelRoot?: THREE.Object3D;\n\n  /** True while the next click on the model places a tag instead of orbiting. */\n  private placingTag = false;\n\n  /** What the armed placement is for, echoed back when the spot is picked. */\n  private placementPoiType: PoiType | null = null;\n\n  /** Position and normal of the last placed tag, in model space, awaiting commit to a POI. */\n  private pendingTagPlacement: ThreeJsTagPlacement | null = null;\n\n  /** Pointer position waiting for a preview pick, coalesced to one per frame. */\n  private pendingPreviewEvent: MouseEvent | null = null;\n\n  /**\n   * Layer carrying the model alone, so the depth pick can render it without the tags.\n   *\n   * Layers are tested per object at render time and children are traversed regardless of whether\n   * their parent passed, so marking the model's own meshes is enough - no re-parenting.\n   */\n  private static readonly PICK_LAYER = 1;\n\n  /** Cache Storage bucket holding downloaded models, and how many to keep. */\n  private static readonly MODEL_CACHE = 'smarterplan-3d-models';\n\n  private static readonly MODEL_CACHE_SIZE = 3;\n\n  private pickTarget?: THREE.WebGLRenderTarget;\n\n  private pickCamera?: THREE.PerspectiveCamera;\n\n  private pickDepthMaterial?: THREE.MeshDepthMaterial;\n\n  private readonly pickPixel = new Uint8Array(4);\n\n  /** Emits once a tag is dropped on the model, so the UI can confirm and persist it. */\n  public tagPlaced$ = new Subject<ThreeJsTagPlacement>();\n\n  /** Emits when the calibration walkthrough is abandoned, so the panel driving it can close. */\n  public alignmentCancelled$ = new Subject<void>();\n\n  /** Translucent marker shown under the cursor while placing. */\n  private placementPreview?: THREE.Sprite;\n\n  private aligning = false;\n  private alignmentPairs: ThreeJsAlignmentPair[] = [];\n  private alignmentSource: { x: number; y: number; z: number } | null = null;\n\n  /** Drives the alignment walkthrough's UI: how many pairs are done and what it wants next. */\n  public alignmentProgress$ = new Subject<{\n    pairs: number;\n    awaiting: 'tag' | 'point' | null;\n    tagId?: string;\n  }>();\n\n  /** In-flight camera move started by goToTag, advanced by the render loop. */\n  private cameraTween: {\n    fromPosition: THREE.Vector3;\n    toPosition: THREE.Vector3;\n    fromTarget: THREE.Vector3;\n    toTarget: THREE.Vector3;\n    startedAt: number;\n    durationMs: number;\n  } | null = null;\n\n  /** Emits true while a heavy OBJ file is being parsed (in a worker, when available), false once done. */\n  public modelLoading$ = new Subject<boolean>();\n\n  /**\n   * Download progress for GLB models, as a 0-1 fraction, or null when the total size is unknown.\n   *\n   * A null means the server did not send Content-Length (chunked responses, some proxies) and no\n   * percentage can be derived; show an indeterminate indicator rather than guessing at one.\n   */\n  public modelLoadProgress$ = new Subject<number | null>();\n\n  /**\n   * Emits when a load actually stopped short, which is not the same as asking it to.\n   *\n   * cancelModelLoad() can arrive after parse() has taken the main thread, and parse cannot be\n   * interrupted - the model finishes loading regardless. Only this tells the UI which of the two\n   * happened, so it does not offer to reload something that is already on screen.\n   */\n  public modelLoadCancelled$ = new Subject<void>();\n\n  // Background parsing of heavy .obj files, provided by the hosting app (see setObjParserWorker).\n  // Angular libraries built with ng-packagr can't bundle `new Worker(new URL(...))` themselves,\n  // so the app instantiates the worker (its build pipeline supports it) and hands it over here.\n  private objParserWorker?: Worker;\n  private objParserPendingRequests = new Map<string, { resolve: (meshes: ParsedMeshData[]) => void; reject: (error: Error) => void }>();\n\n  constructor(private ngZone: NgZone) { }\n\n  /**\n   * Registers a Web Worker used to parse heavy .obj files off the main thread.\n   * Must be instantiated by the consuming app (e.g. `new Worker(new URL('./obj-parser.worker', import.meta.url))`),\n   * since a library packaged with ng-packagr cannot bundle worker files itself.\n   * When no worker is provided, loadObjModel falls back to parsing on the main thread.\n   */\n  setObjParserWorker(worker: Worker): void {\n    this.objParserWorker = worker;\n    this.objParserWorker.onmessage = ({ data }: MessageEvent<ObjParserWorkerResponse>) => {\n      const pending = this.objParserPendingRequests.get(data.requestId);\n      if (!pending) {\n        return;\n      }\n      this.objParserPendingRequests.delete(data.requestId);\n      if (data.success && data.meshes) {\n        pending.resolve(data.meshes);\n      } else {\n        pending.reject(new Error(data.error || 'Unknown error while parsing OBJ file in worker'));\n      }\n    };\n  }\n\n  private requestObjParseInWorker(objUrl: string): Promise<ParsedMeshData[]> {\n    return new Promise((resolve, reject) => {\n      const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;\n      this.objParserPendingRequests.set(requestId, { resolve, reject });\n      this.objParserWorker!.postMessage({ requestId, objUrl });\n      // Diagnostic only: large models legitimately take a while, this isn't a timeout/abort,\n      // just a signal in case the worker went silent (e.g. it ran out of memory mid-parse).\n      setTimeout(() => {\n        if (this.objParserPendingRequests.has(requestId)) {\n          console.warn(`ThreeJsService: obj-parser worker has not replied after 60s for request ${requestId} (objUrl=${objUrl}). Still waiting - large files can take a while, but this may also mean the worker hung or ran out of memory.`);\n        }\n      }, 60000);\n    });\n  }\n\n  /** Rebuilds a THREE.Mesh from the raw typed arrays sent back by the parser worker. */\n  private meshFromParsedData(data: ParsedMeshData, materials?: any): THREE.Mesh {\n    const geometry = new THREE.BufferGeometry();\n    geometry.setAttribute('position', new THREE.BufferAttribute(data.position, 3));\n    if (data.uv) {\n      geometry.setAttribute('uv', new THREE.BufferAttribute(data.uv, 2));\n    }\n    // Index has to be set before any normal computation, which reads it to average shared faces.\n    if (data.index) {\n      geometry.setIndex(new THREE.BufferAttribute(data.index, 1));\n    }\n    if (data.normal) {\n      geometry.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));\n    } else {\n      geometry.computeVertexNormals();\n    }\n    // Box3.setFromObject() reuses an already-set boundingBox instead of walking every vertex,\n    // so adopting the worker's makes framing the camera cheap no matter how dense the mesh is.\n    if (data.boundingBox) {\n      geometry.boundingBox = new THREE.Box3(\n        new THREE.Vector3(...data.boundingBox.min),\n        new THREE.Vector3(...data.boundingBox.max),\n      );\n    }\n\n    const resolvedMaterials = data.materialNames.map((name) => {\n      const material = materials && name ? materials.create(name) : undefined;\n      if (!material) {\n        console.warn(`ThreeJsService: no MTL material named \"${name}\" for mesh \"${data.name}\", using a plain fallback (no texture).`);\n      }\n      return material || new THREE.MeshPhongMaterial();\n    });\n\n    let mesh: THREE.Mesh;\n    if (data.groups && data.groups.length > 0) {\n      data.groups.forEach((group) => geometry.addGroup(group.start, group.count, group.materialIndex));\n      mesh = new THREE.Mesh(geometry, resolvedMaterials);\n    } else {\n      mesh = new THREE.Mesh(geometry, resolvedMaterials[0]);\n    }\n    mesh.name = data.name;\n    return mesh;\n  }\n\n  init(canvas: HTMLCanvasElement): void {\n    // This service is a singleton but the viewer component is rebuilt on every navigation, so state\n    // from the previous scene is still here. Two things outlive it and have to go first:\n    //\n    //  - A download still in flight. Its onLoaded resolves against whatever `this.scene` points at\n    //    by then, so the model being abandoned would be handed to the scene built below.\n    //  - The tag group, which is a field and keeps its sprites. They would be re-parented under the\n    //    new model and show the previous visit's tags on it.\n    this.discardCurrentLoad();\n    this.clearTags();\n    this.cameraTween = null;\n    this.modelRoot = undefined;\n\n    // 1. Setup Scene\n    this.scene = new THREE.Scene();\n    this.scene.background = new THREE.Color(0xe0f7ff); // from POC\n\n    // 2. Setup Camera\n    this.camera = new THREE.PerspectiveCamera(75, canvas.clientWidth / canvas.clientHeight, 0.1, 10000);\n    this.camera.position.set(0, 5, 10); // will be overridden later if passed\n\n    // 3. Setup WebGL Renderer\n    this.renderer = new THREE.WebGLRenderer({ canvas, antialias: true });\n    this.renderer.setSize(canvas.clientWidth, canvas.clientHeight);\n    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));\n    this.observeCanvasResize(canvas);\n    \n    // Fix for Three.js r147 vs r152+ color management\n    if ('outputColorSpace' in this.renderer) {\n      (this.renderer as any).outputColorSpace = 'srgb'; // THREE.SRGBColorSpace\n    } else {\n      (this.renderer as any).outputEncoding = 3001; // THREE.sRGBEncoding\n    }\n\n    // Without tone mapping anything brighter than 1.0 is simply cut off to pure white. Captured\n    // textures carry a small fraction of very bright pixels - sky reflected in windows, sunlit\n    // render - and once lighting pushes those past the limit they flatten into white specks with\n    // no detail left. Rolling the highlights off instead keeps that detail and keeps bright areas\n    // reading as bright rather than blown.\n    this.renderer.toneMapping = THREE.ACESFilmicToneMapping;\n    this.renderer.toneMappingExposure = 1.0;\n\n    // 4. Lighting, kept deliberately restrained and neutral.\n    //\n    // Captured/photogrammetry models already have lighting baked into their textures (the sun and\n    // shadows came with the photos), so lighting them again distorts what they actually look like.\n    // The intensities below add up to roughly 1.0 on a surface facing the viewer, which renders the\n    // texture at its true value. Anything above 1.0 is clipped to pure white by the renderer, which\n    // is what turns bright areas into flat white patches with no detail left in them.\n    //\n    // Neutral white is used rather than a warm tint for the same reason: a tinted light shifts every\n    // colour in the model away from what was captured.\n    const ambientLight = new THREE.AmbientLight(0xffffff, 0.7);\n    this.scene.add(ambientLight);\n\n    // Headlight rather than a fixed sun: parented to the camera so it always points at whatever is\n    // being looked at, giving shape to surfaces without ever leaving a face unlit. No shadow casting\n    // - shadows would double up with the ones already baked into the textures, and the shadow map\n    // was a real cost per frame.\n    const headLight = new THREE.DirectionalLight(0xffffff, 0.35);\n    headLight.position.set(0, 0, 1);\n    this.camera.add(headLight);\n    // A light only contributes while it is part of the scene graph, and this one hangs off the camera.\n    this.scene.add(this.camera);\n\n    // 5. Setup Controls (from POC)\n    this.controls = new OrbitControls(this.camera, this.renderer.domElement);\n    this.controls.rotateSpeed = 1.0;\n    this.controls.dampingFactor = 0.1;\n    this.controls.enableDamping = true;\n    this.controls.mouseButtons = {\n      LEFT: THREE.MOUSE.ROTATE,\n      MIDDLE: THREE.MOUSE.DOLLY,\n      RIGHT: THREE.MOUSE.PAN,\n    };\n    this.controls.target.set(0, 0, 0);\n\n    // Event listeners on controls to differentiate dragging vs clicking\n    this.controls.addEventListener('start', () => {\n      this.isDraggingTimer = setTimeout(() => {\n        this.isDraggingCamera = true;\n      }, 150);\n    });\n\n    this.controls.addEventListener('end', () => {\n      clearTimeout(this.isDraggingTimer);\n      if (this.isDraggingCamera) {\n        setTimeout(() => {\n          this.isDraggingCamera = false;\n        }, 250);\n      }\n    });\n\n    // Interaction Event Listeners on canvas\n    canvas.addEventListener('click', this.onMouseClick.bind(this), false);\n    canvas.addEventListener('mousemove', this.onMouseMove.bind(this), false);\n\n    // Escape backs out of placement and calibration. On the window rather than the canvas, which\n    // would need focus the user has no reason to have given it - they are aiming with the mouse.\n    // Removed first because this service is a singleton: init() runs again for every canvas, and\n    // the previous registration would otherwise still be attached.\n    window.removeEventListener('keydown', this.onKeyDown);\n    this.pickTarget?.dispose();\n    this.pickTarget = undefined;\n    this.pickDepthMaterial?.dispose();\n    this.pickDepthMaterial = undefined;\n    this.pickCamera = undefined;\n    window.addEventListener('keydown', this.onKeyDown);\n\n    // 6. Start the render loop\n    this.ngZone.runOutsideAngular(() => {\n      this.animate();\n    });\n  }\n\n  /**\n   * Path (served by the app) holding basis_transcoder.js/.wasm, which KTX2Loader needs to turn\n   * Basis Universal textures into whatever compressed format the local GPU actually supports.\n   */\n  private ktx2TranscoderPath = 'assets/basis/';\n\n  /** Overrides where the Basis transcoder files are served from. */\n  setKtx2TranscoderPath(path: string): void {\n    this.ktx2TranscoderPath = path;\n  }\n\n  /**\n   * Loads a base 3D model in GLTF/GLB format - the preferred format for large models.\n   * Unlike .obj, geometry arrives as binary typed arrays (no text parsing to offload to a worker)\n   * and stays indexed, so far less data reaches the GPU. KTX2 textures are supported too: they\n   * stay compressed in VRAM instead of being decoded to raw pixels like JPEG/PNG.\n   */\n  loadGLTFModel(url: string, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}, cacheKey?: string): void {\n    const loader = new GLTFLoader();\n\n    // KTX2 needs the renderer to report which compressed formats this GPU accepts, so this has to\n    // happen after init(). Guarded so a model without KTX2 textures still loads if it's missing.\n    if (this.renderer) {\n      try {\n        const ktx2Loader = new KTX2Loader()\n          .setTranscoderPath(this.ktx2TranscoderPath)\n          .detectSupport(this.renderer);\n        loader.setKTX2Loader(ktx2Loader);\n      } catch (error) {\n        console.warn('ThreeJsService: could not set up KTX2 texture support, falling back to uncompressed textures.', error);\n      }\n    }\n    // Lets gltfpack/gltf-transform output using EXT_meshopt_compression load without extra setup.\n    loader.setMeshoptDecoder(MeshoptDecoder);\n\n    this.modelLoading$.next(true);\n    this.modelLoadProgress$.next(0);\n\n    // Order matters: normals must exist before anisotropy, and the Phong conversion has to run\n    // before side/flatShading are touched so those settings land on the materials we keep.\n    const onLoaded = (gltf: any) => {\n      this.convertToPhongMaterials(gltf.scene);\n      this.forceDoubleSidedMaterials(gltf.scene);\n      this.ensureVertexNormals(gltf.scene);\n      this.tuneTextureSampling(gltf.scene);\n      this.placeLoadedObjectInScene(gltf.scene, cameraPosition, rotation);\n      this.modelLoading$.next(false);\n    };\n    const onError = (error: any) => {\n      // Cancelling is a decision, not a failure: clear the overlay without an error in the console.\n      if (error?.name === 'AbortError') {\n        // Only a cancel of the load that is still current came from the user; anything else is this\n        // load having been superseded or discarded.\n        if (this.loadAbortController?.signal.aborted) {\n          this.modelLoadCancelled$.next();\n        }\n      } else {\n        console.error('Error loading GLTF model:', error);\n      }\n      this.modelLoading$.next(false);\n      this.modelLoadProgress$.next(null);\n    };\n\n    // GLTFLoader decodes embedded images with createImageBitmap when the browser offers it, and on\n    // large texture atlases that path returns visibly corrupt data - scattered white blocks across\n    // the model. The exact same bytes decoded through an HTMLImageElement, which is what the .obj\n    // path uses via MTLLoader, come out clean. GLTFLoader already falls back to that decoder for\n    // Safari and older Firefox; this simply extends the fallback to cover this case too.\n    //\n    // The decoder is chosen while GLTFParser is being constructed, which happens synchronously\n    // inside parse(), so hiding createImageBitmap only has to hold across that call rather than\n    // for the whole download.\n    this.fetchWithProgress(url, cacheKey)\n      // parse() holds the main thread for seconds on a large model. Yield until the browser has\n      // actually painted first, otherwise the final progress update never reaches the screen and\n      // the bar appears to stall short of the end.\n      .then((buffer) => this.afterNextPaint().then(() => buffer))\n      .then((buffer) => {\n        // parse() cannot be interrupted, so a cancel that lands during the paint yield has to be\n        // caught here - the last moment before the main thread is committed for several seconds.\n        if (this.loadAbortController?.signal.aborted) {\n          throw new DOMException('Model load cancelled', 'AbortError');\n        }\n        const globalScope = globalThis as any;\n        const originalCreateImageBitmap = globalScope.createImageBitmap;\n        globalScope.createImageBitmap = undefined;\n        try {\n          loader.parse(buffer, url.substring(0, url.lastIndexOf('/') + 1), onLoaded, onError);\n        } finally {\n          globalScope.createImageBitmap = originalCreateImageBitmap;\n        }\n      })\n      .catch(onError);\n  }\n\n  /**\n   * Stops the model download in progress, if any.\n   *\n   * Only the download can be interrupted: parse() runs synchronously and holds the main thread until\n   * it finishes, so once it has begun there is nothing to cancel. In practice the download is the\n   * long part, which is where someone reaches for this.\n   */\n  cancelModelLoad(): void {\n    this.loadAbortController?.abort();\n  }\n\n  /**\n   * Abandons the load in progress without reporting it as cancelled.\n   *\n   * Dropping the controller is what makes the difference: onError treats an abort as user-initiated\n   * only while the controller that aborted is still the current one. Tearing down or rebuilding the\n   * scene is not something the person asked for, so it must not surface as \"loading cancelled\".\n   */\n  private discardCurrentLoad(): void {\n    this.loadAbortController?.abort();\n    this.loadAbortController = undefined;\n  }\n\n  /**\n   * Resolves once the browser has painted at least one frame.\n   *\n   * A requestAnimationFrame callback runs *before* that frame is painted, so a single one is not\n   * enough to guarantee pending DOM changes are on screen; the second fires after the first frame\n   * has gone out. Falls back to a timeout where rAF isn't available (SSR, tests).\n   */\n  private afterNextPaint(): Promise<void> {\n    if (typeof requestAnimationFrame !== 'function') {\n      return new Promise((resolve) => setTimeout(resolve, 0));\n    }\n    return new Promise((resolve) => {\n      requestAnimationFrame(() => requestAnimationFrame(() => resolve()));\n    });\n  }\n\n  /**\n   * Downloads a file, reporting progress on modelLoadProgress$ as it arrives.\n   *\n   * GLTFLoader.load() would report progress through XHR, but this path deliberately uses fetch() +\n   * parse() instead (see loadGLTFModel for why), so progress is read off the response stream here.\n   * That is also the more useful number: on a model of this size the download dominates, and the\n   * stream reports it as it happens rather than in one jump at the end.\n   */\n  private async fetchWithProgress(url: string, cacheKey?: string): Promise<ArrayBuffer> {\n    // A load already running is replaced, not raced: whichever finished last would otherwise win.\n    this.loadAbortController?.abort();\n    this.loadAbortController = new AbortController();\n    const { signal } = this.loadAbortController;\n\n    const cached = await this.readModelFromCache(cacheKey);\n    if (cached) {\n      this.modelLoadProgress$.next(1);\n      return cached;\n    }\n\n    const response = await fetch(url, { signal });\n    if (!response.ok) {\n      throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);\n    }\n\n    const contentLength = Number(response.headers.get('Content-Length'));\n    const total = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : 0;\n\n    // Without a readable stream (older browsers, some polyfills) there is nothing to measure, so\n    // fall back to a plain buffered read and let the UI show an indeterminate indicator.\n    if (!response.body?.getReader) {\n      this.modelLoadProgress$.next(null);\n      return response.arrayBuffer();\n    }\n\n    const reader = response.body.getReader();\n\n    // With a known size, write chunks straight into one pre-allocated buffer. Collecting them in an\n    // array and concatenating afterwards would hold both copies at once - on a 164 MB model that is\n    // an avoidable 300+ MB peak.\n    const buffer = total > 0 ? new Uint8Array(total) : null;\n    const chunks: Uint8Array[] = [];\n    let usingBuffer = buffer !== null;\n    let received = 0;\n    // Chunks arrive in tens of kilobytes, so a 164 MB model produces thousands of them. Emitting on\n    // every one would run change detection just as often to move a bar that is measured in whole\n    // percent, so only report when the displayed value would actually change.\n    let lastReported = -1;\n\n    if (total === 0) {\n      this.modelLoadProgress$.next(null);\n    }\n\n    for (;;) {\n      const { done, value } = await reader.read();\n      if (done) {\n        break;\n      }\n      if (signal.aborted) {\n        // Free the connection rather than leaving it draining in the background.\n        await reader.cancel();\n        throw new DOMException('Model load cancelled', 'AbortError');\n      }\n      if (usingBuffer && received + value.length > total) {\n        // Content-Length understated the real size. Move what we have into the chunk list and stay\n        // there for the rest of the response, rather than truncating the tail.\n        chunks.push(buffer.slice(0, received));\n        usingBuffer = false;\n      }\n      if (usingBuffer) {\n        buffer.set(value, received);\n      } else {\n        chunks.push(value);\n      }\n      received += value.length;\n      if (total > 0) {\n        const percent = Math.min(Math.round((received / total) * 100), 100);\n        if (percent !== lastReported) {\n          lastReported = percent;\n          this.modelLoadProgress$.next(percent / 100);\n        }\n      }\n    }\n\n    // The stream can end below the advertised size (or with no size at all). Land on a full bar\n    // rather than leaving it stuck at whatever the last chunk happened to reach.\n    if (total > 0 && lastReported !== 100) {\n      this.modelLoadProgress$.next(1);\n    }\n\n    let result: ArrayBuffer;\n    if (usingBuffer && received === total) {\n      result = buffer.buffer;\n    } else if (usingBuffer) {\n      // Fewer bytes than advertised: hand back exactly what arrived.\n      result = buffer.buffer.slice(0, received);\n    } else {\n      const merged = new Uint8Array(received);\n      let offset = 0;\n      chunks.forEach((chunk) => {\n        merged.set(chunk, offset);\n        offset += chunk.length;\n      });\n      result = merged.buffer;\n    }\n\n    await this.writeModelToCache(cacheKey, result);\n    return result;\n  }\n\n  /**\n   * The model store, or null where the browser will not give us one.\n   *\n   * Cache Storage needs a secure context, so it is absent over plain http and in some embedded\n   * webviews. Every caller treats that as a miss - caching is an optimisation, never a requirement.\n   */\n  private async openModelCache(): Promise<Cache | null> {\n    if (typeof caches === 'undefined') {\n      return null;\n    }\n    try {\n      return await caches.open(ThreeJsService.MODEL_CACHE);\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * A cached copy of this model, if one was stored.\n   *\n   * Keyed by the S3 key rather than the URL it is fetched from: that URL is signed, so it carries a\n   * fresh signature and expiry every time and would never match twice. The browser's own HTTP cache\n   * misses for the same reason, which is why this exists at all.\n   */\n  private async readModelFromCache(cacheKey?: string): Promise<ArrayBuffer | null> {\n    if (!cacheKey) {\n      return null;\n    }\n    try {\n      const cache = await this.openModelCache();\n      const hit = await cache?.match(this.modelCacheUrl(cacheKey));\n      return hit ? await hit.arrayBuffer() : null;\n    } catch {\n      return null;\n    }\n  }\n\n  /** Stores a model for next time, evicting the oldest once a few are held. */\n  private async writeModelToCache(cacheKey: string | undefined, model: ArrayBuffer): Promise<void> {\n    if (!cacheKey) {\n      return;\n    }\n    try {\n      const cache = await this.openModelCache();\n      if (!cache) {\n        return;\n      }\n      await cache.put(this.modelCacheUrl(cacheKey), new Response(model));\n\n      // Models run to hundreds of megabytes, so this cannot grow without limit. Cache Storage keeps\n      // insertion order, which makes the front of the list the least recently stored.\n      const keys = await cache.keys();\n      await Promise.all(\n        keys.slice(0, Math.max(0, keys.length - ThreeJsService.MODEL_CACHE_SIZE))\n          .map((key) => cache.delete(key))\n      );\n    } catch {\n      // Out of quota, private browsing, storage disabled: the model is already loaded either way.\n    }\n  }\n\n  /** Cache Storage keys on a URL, so the S3 key is expressed as one. It is never requested. */\n  private modelCacheUrl(cacheKey: string): string {\n    return `https://3d-model-cache.smarterplan.local/${encodeURIComponent(cacheKey)}`;\n  }\n\n  /**\n   * Fits the camera's clipping planes to how big the model actually is.\n   *\n   * Depth precision depends on the far/near ratio, and the fixed 0.1 / 10000 the camera starts with\n   * is a ratio of 100000 for a model only ~10 units across. That wastes most of the depth buffer on\n   * empty space and lets nearly coincident surfaces - which captured meshes have everywhere -\n   * flicker against each other.\n   */\n  private adjustClippingPlanes(radius: number): void {\n    if (radius < 10) {\n      this.camera.near = 0.01;\n      this.camera.far = 100;\n    } else if (radius < 100) {\n      this.camera.near = 0.1;\n      this.camera.far = 1000;\n    } else if (radius < 1000) {\n      this.camera.near = 10;\n      this.camera.far = 10000;\n    } else {\n      this.camera.near = 100;\n      this.camera.far = 1000000;\n    }\n    this.camera.updateProjectionMatrix();\n  }\n\n  /**\n   * Swaps the PBR materials GLTFLoader builds for the plain Phong ones the .obj path produces.\n   *\n   * MeshStandardMaterial keeps a specular reflection even at metalness 0, since every dielectric\n   * reflects some light, and Fresnel drives that reflection towards white as a surface turns away\n   * from the viewer. On an aerial view of a facade most surfaces sit at exactly those grazing\n   * angles, which paints white highlights over window frames and roof edges - the same model\n   * loaded as .obj never shows them, because MTLLoader builds Phong materials and OBJLoader zeroes\n   * their specular when the .mtl declares Ns 0.\n   *\n   * Captured models carry their lighting in the texture and want no specular response at all, so\n   * matching the .obj path here is both the fix and the more faithful choice.\n   */\n  private convertToPhongMaterials(root: THREE.Object3D): void {\n    const converted = new Map<any, THREE.MeshPhongMaterial>();\n\n    root.traverse((child) => {\n      const mesh = child as THREE.Mesh;\n      if (!(mesh as any).isMesh) {\n        return;\n      }\n\n      const convert = (source: any): any => {\n        if (!source || !(source as any).isMeshStandardMaterial) {\n          return source;\n        }\n        if (!converted.has(source)) {\n          const phong = new THREE.MeshPhongMaterial({\n            map: source.map,\n            color: source.color,\n            transparent: source.transparent,\n            opacity: source.opacity,\n            alphaTest: source.alphaTest,\n            side: source.side,\n            specular: new THREE.Color(0x000000),\n            shininess: 0,\n          });\n          phong.name = source.name;\n          converted.set(source, phong);\n        }\n        return converted.get(source);\n      };\n\n      mesh.material = Array.isArray(mesh.material)\n        ? mesh.material.map(convert)\n        : convert(mesh.material);\n    });\n  }\n\n  /**\n   * Renders every material double-sided.\n   *\n   * Reality capture meshes routinely contain triangles with reversed winding - an artefact of the\n   * reconstruction, not of the file. With the default FrontSide those triangles are culled, leaving\n   * scattered holes that show the scene background through the model. Against a light background\n   * they read as white specks with no discernible pattern.\n   *\n   * Drawing both sides costs a little fill rate but is what makes captured geometry render as\n   * solid; other viewers of this kind of content do the same unconditionally.\n   */\n  private forceDoubleSidedMaterials(root: THREE.Object3D): void {\n    const seen = new Set<any>();\n    root.traverse((child) => {\n      const mesh = child as THREE.Mesh;\n      if (!(mesh as any).isMesh) {\n        return;\n      }\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\n      materials.forEach((material: any) => {\n        if (material && !seen.has(material)) {\n          seen.add(material);\n          material.side = THREE.DoubleSide;\n          material.needsUpdate = true;\n        }\n      });\n    });\n  }\n\n  /**\n   * Computes real vertex normals for any geometry that arrived without them.\n   *\n   * A glTF without a NORMAL attribute is spec-compliant, and GLTFLoader handles it by switching the\n   * material to flatShading, which makes the shader derive the normal per pixel from screen-space\n   * derivatives. That derivation collapses on the degenerate, needle-thin triangles that reality\n   * capture meshes are full of: the face has almost no area, the derived normal is meaningless, and\n   * lighting blows those fragments out to white specks - densest exactly where fine detail is.\n   *\n   * Computing normals from the geometry instead is robust to those triangles, since a degenerate\n   * face contributes almost nothing to the average and its neighbours dominate.\n   */\n  private ensureVertexNormals(root: THREE.Object3D): void {\n    root.traverse((child) => {\n      const mesh = child as THREE.Mesh;\n      if (!(mesh as any).isMesh) {\n        return;\n      }\n      const geometry = mesh.geometry as THREE.BufferGeometry;\n      if (geometry.getAttribute('normal')) {\n        return;\n      }\n\n      geometry.computeVertexNormals();\n\n      // GLTFLoader already switched these materials to flatShading because normals were missing;\n      // now that real ones exist, let them be used instead of the derivative fallback.\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\n      materials.forEach((material: any) => {\n        if (material && material.flatShading) {\n          material.flatShading = false;\n          material.needsUpdate = true;\n        }\n      });\n    });\n  }\n\n  /**\n   * Configures how every texture in a model is sampled: maximum anisotropy, and no mipmapping.\n   *\n   * Photogrammetry atlases pack their UV islands with unused gutter pixels between them. Mipmapping\n   * averages neighbouring pixels at each level, so those gutters bleed further into the islands the\n   * smaller the level gets - and viewing the whole model at once uses the smallest levels, painting\n   * bright gutter pixels over the edges of fine detail. Sampling the full-resolution image avoids\n   * that, at the cost of some shimmer on minified surfaces.\n   *\n   * Note that anisotropy only takes effect while mipmapping is on, so with the settings below it is\n   * inert; it is set anyway so the sampling stays correct for anyone who re-enables mipmaps here.\n   */\n  private tuneTextureSampling(root: THREE.Object3D): void {\n    if (!this.renderer) {\n      return;\n    }\n    const maxAnisotropy = this.renderer.capabilities.getMaxAnisotropy();\n    if (!maxAnisotropy || maxAnisotropy <= 1) {\n      return;\n    }\n\n    const seen = new Set<any>();\n    root.traverse((child) => {\n      const mesh = child as THREE.Mesh;\n      if (!(mesh as any).isMesh) {\n        return;\n      }\n      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];\n      materials.forEach((material: any) => {\n        if (!material) {\n          return;\n        }\n        // Same texture is reused across the model's materials; only touch each one once.\n        ['map', 'normalMap', 'roughnessMap', 'metalnessMap', 'emissiveMap', 'aoMap'].forEach((slot) => {\n          const texture = material[slot];\n          if (texture && !seen.has(texture)) {\n            seen.add(texture);\n            texture.anisotropy = maxAnisotropy;\n            texture.generateMipmaps = false;\n            texture.minFilter = THREE.LinearFilter;\n            texture.needsUpdate = true;\n          }\n        });\n      });\n    });\n  }\n\n  /**\n   * Loads an OBJ model with MTL.\n   * The heavy text-parsing step runs in a Web Worker when one has been registered via\n   * setObjParserWorker (see there for why the app, not this library, provides it); this keeps\n   * the main thread free while large architecture models (millions of vertices) are parsed.\n   * Falls back to parsing on the main thread otherwise.\n   */\n  loadObjModel(mtlUrl: string, objUrl: string, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}): void {\n    const mtlLoader = new MTLLoader();\n    const basePath = mtlUrl.substring(0, mtlUrl.lastIndexOf('/') + 1);\n    mtlLoader.setPath(basePath);\n    const mtlFileName = mtlUrl.substring(mtlUrl.lastIndexOf('/') + 1);\n\n    this.modelLoading$.next(true);\n\n    mtlLoader.load(mtlFileName, (materials) => {\n      materials.preload();\n\n      if (this.objParserWorker) {\n        this.requestObjParseInWorker(objUrl)\n          .then((meshes) => {\n            const group = new THREE.Group();\n            meshes.forEach((meshData) => {\n              group.add(this.meshFromParsedData(meshData, materials));\n            });\n            this.placeLoadedObjectInScene(group, cameraPosition, rotation);\n          })\n          .catch((error) => {\n            console.error('Error parsing OBJ model in worker:', error);\n          })\n          .finally(() => this.modelLoading$.next(false));\n        return;\n      }\n\n      const objLoader = new OBJLoader();\n      objLoader.setMaterials(materials);\n\n      objLoader.load(objUrl, (object) => {\n        this.placeLoadedObjectInScene(object, cameraPosition, rotation);\n        this.modelLoading$.next(false);\n      }, undefined, (error) => {\n        console.error('Error loading OBJ model:', error);\n        this.modelLoading$.next(false);\n      });\n    }, undefined, (error) => {\n      console.error('Error loading MTL file:', error);\n      this.modelLoading$.next(false);\n    });\n  }\n\n  /** Centers, scales and adds a loaded object to the scene, then frames the camera on it. */\n  private placeLoadedObjectInScene(object: THREE.Object3D, cameraPosition?: {x: number, y: number, z: number}, rotation?: {x: number, y: number, z: number}): void {\n    const box = new THREE.Box3().setFromObject(object);\n    const center = box.getCenter(new THREE.Vector3());\n    const size = box.getSize(new THREE.Vector3());\n    const maxDim = Math.max(size.x, size.y, size.z);\n    const scale = maxDim > 0 ? 10 / maxDim : 1;\n\n    // Two nested groups so tags can share the model's frame: `centered` carries the offset that\n    // moves the model's own origin to the scene origin, `group` carries the scale. A tag positioned\n    // with raw POI coordinates then lands in the same place the model's geometry does.\n    const group = new THREE.Group();\n    const centered = new THREE.Group();\n    centered.position.sub(center);\n\n    if (rotation) {\n      object.rotation.set(rotation.x, rotation.y, rotation.z);\n    }\n\n    this.modelRoot = object;\n    // Marks the model for the depth pick, which renders this layer alone - so tags and the ghost\n    // itself cannot end up being what the cursor reports as the surface under it.\n    object.traverse((child) => child.layers.enable(ThreeJsService.PICK_LAYER));\n    centered.add(object);\n    centered.add(this.tagGroup);\n    group.add(centered);\n    group.scale.setScalar(scale);\n\n    this.scene.add(group);\n\n    // Tags registered before the model finished loading were sized against the old scale.\n    this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));\n\n    this.adjustClippingPlanes((size.length() / 2) * scale);\n\n    if (cameraPosition) {\n      this.camera.position.set(cameraPosition.x, cameraPosition.y, cameraPosition.z);\n    } else {\n      this.camera.position.set(0, 5, 15);\n    }\n    this.controls.target.set(0, 0, 0);\n    this.controls.update();\n  }\n\n  /**\n   * Keeps the drawing buffer and camera matched to the canvas as it is resized.\n   *\n   * renderer.setSize() writes explicit pixel width/height into the canvas's style, overriding the\n   * 100%/100% it starts with. Without this, the canvas keeps whatever size it had at startup: hiding\n   * the top menu grows the container, the canvas does not follow, and the strip that opens up shows\n   * the page behind it instead of the scene.\n   *\n   * The parent is observed rather than the canvas, because resizing the canvas is what this reacts\n   * to - watching the element we resize would retrigger the observer.\n   */\n  private observeCanvasResize(canvas: HTMLCanvasElement): void {\n    const container = canvas.parentElement;\n    if (!container || typeof ResizeObserver === 'undefined') {\n      return;\n    }\n\n    this.canvasResizeObserver = new ResizeObserver(() => {\n      const width = container.clientWidth;\n      const height = container.clientHeight;\n      if (width === 0 || height === 0) {\n        return;\n      }\n      this.camera.aspect = width / height;\n      this.camera.updateProjectionMatrix();\n      this.renderer.setSize(width, height);\n    });\n    this.canvasResizeObserver.observe(container);\n  }\n\n  /**\n   * Starts the alignment walkthrough: pick a tag, then click where it really is, three times.\n   *\n   * Existing tags are the correspondences - they already carry the stored coordinate, so the person\n   * only has to supply the matching spot on the model. No new records are written; nothing is\n   * applied until solveAlignmentFromPairs() succeeds.\n   */\n  startTagAlignment(): void {\n    this.aligning = true;\n    this.alignmentPairs = [];\n    this.alignmentSource = null;\n    if (this.renderer) {\n      this.renderer.domElement.style.cursor = 'crosshair';\n    }\n    this.alignmentProgress$.next({ pairs: 0, awaiting: 'tag' });\n  }\n\n  cancelTagAlignment(): void {\n    const wasAligning = this.aligning;\n    this.aligning = false;\n    this.alignmentPairs = [];\n    this.alignmentSource = null;\n    this.pendingPreviewEvent = null;\n    this.removePlacementPreview();\n    if (this.renderer) {\n      this.renderer.domElement.style.cursor = 'default';\n    }\n    this.alignmentProgress$.next({ pairs: 0, awaiting: null });\n    if (wasAligning) {\n      this.alignmentCancelled$.next();\n    }\n  }\n\n  isAligningTags(): boolean {\n    return this.aligning;\n  }\n\n  /**\n   * Whether the pointer should be showing the placement ghost.\n   *\n   * True while placing a tag, and while calibrating once a tag has been picked - that second click\n   * is the same question (\"where on the model?\") and deserves the same aiming aid. Not true for the\n   * first half of a pair, which is a click on a tag, not on the model.\n   */\n  private isPreviewingPlacement(): boolean {\n    return this.placingTag || (this.aligning && !!this.alignmentSource);\n  }\n\n  /** Whether a tag is currently registered for this element. */\n  hasTag(elementId: string): boolean {\n    return this.tagSprites.has(elementId);\n  }\n\n  /**\n   * Solves and applies the alignment collected so far, returning it so the caller can persist it.\n   *\n   * Returns null when the three tags turn out to be collinear, in which case nothing is applied and\n   * the walkthrough stays open for the person to pick a better third point.\n   */\n  solveAlignmentFromPairs(): ThreeJsAlignment | null {\n    const alignment = solveThreeJsAlignment(this.alignmentPairs);\n    if (!alignment) {\n      return null;\n    }\n    this.setTagAlignment(alignment);\n    this.aligning = false;\n    this.pendingPreviewEvent = null;\n    this.removePlacementPreview();\n    this.renderer.domElement.style.cursor = 'default';\n    this.alignmentProgress$.next({ pairs: this.alignmentPairs.length, awaiting: null });\n    return alignment;\n  }\n\n  /** Handles a click while the alignment walkthrough is running. */\n  private handleAlignmentClick(event: MouseEvent): void {\n    if (!this.alignmentSource) {\n      // First half of a pair: which tag are we talking about?\n      const hit = this.raycaster.intersectObjects(this.tagGroup.children, false)[0];\n      if (!hit) {\n        return;\n      }\n      // The sprite's own position is the stored coordinate, untouched by any alignment already\n      // applied - that transform lives on the group, not on the sprite.\n      const stored = hit.object.position;\n      this.alignmentSource = { x: stored.x, y: stored.y, z: stored.z };\n      this.alignmentProgress$.next({\n        pairs: this.alignmentPairs.length,\n        awaiting: 'point',\n        tagId: hit.object.name,\n      });\n      return;\n    }\n\n    // Second half: where that tag actually belongs on the model.\n    const target = this.pickAlignmentTarget(event);\n    if (!target) {\n      return;\n    }\n    this.alignmentPairs.push({ source: this.alignmentSource, target });\n    this.alignmentSource = null;\n    // The ghost belongs to the click that just happened; the next half is a click on a tag.\n    this.pendingPreviewEvent = null;\n    this.removePlacementPreview();\n    this.alignmentProgress$.next({\n      pairs: this.alignmentPairs.length,\n      awaiting: this.alignmentPairs.length >= 3 ? null : 'tag',\n    });\n  }\n\n  /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */\n  startTagPlacement(poiType: PoiType | null = null): void {\n    this.placingTag = true;\n    this.placementPoiType = poiType;\n    this.pendingTagPlacement = null;\n    if (this.renderer) {\n      this.renderer.domElement.style.cursor = 'crosshair';\n    }\n  }\n\n  /** Leaves placement mode without placing anything. */\n  cancelTagPlacement(): void {\n    this.placingTag = false;\n    this.pendingTagPlacement = null;\n    this.pendingPreviewEvent = null;\n    this.removePlacementPreview();\n    if (this.renderer) {\n      this.renderer.domElement.style.cursor = 'default';\n    }\n  }\n\n  /**\n   * Shows a translucent tag under the cursor while placing, so the spot is visible before commiting.\n   *\n   * Matterport does this with a tag that follows the pointer; the equivalent here is a preview\n   * sprite that gets removed the moment the real tag takes its place.\n   */\n  private updatePlacementPreview(event: MouseEvent): void {\n    const position = this.pickPointOnGpu(event);\n    if (!position) {\n      this.removePlacementPreview();\n      this.renderer.domElement.style.cursor = 'not-allowed';\n      return;\n    }\n\n    this.renderer.domElement.style.cursor = 'crosshair';\n    if (!this.placementPreview) {\n      this.placementPreview = new THREE.Sprite(\n        new THREE.SpriteMaterial({\n          map: this.createTagTexture('#9E9E9E'),\n          depthTest: false,\n          transparent: true,\n          opacity: 0.6,\n        })\n      );\n      this.placementPreview.renderOrder = 999;\n      this.tagGroup.add(this.placementPreview);\n      this.scaleTagForModel(this.placementPreview);\n    }\n    this.placementPreview.position.copy(position);\n  }\n\n  /**\n   * The point under the cursor, read from the depth buffer instead of raycast, in tag space.\n   *\n   * A raycast walks every triangle of the mesh it hits: on a captured model that is millions of\n   * them, tens of milliseconds, every time the pointer moves. Coalescing to one per frame did not\n   * help, because the cost is the pick itself - it simply became one slow frame instead of several.\n   *\n   * Rendering the model's depth into a single pixel under the cursor answers the same question on\n   * the GPU in constant time, whatever the model's size. The camera's view offset is what narrows\n   * the whole image down to that one pixel, so the value read back is the depth the cursor is over.\n   *\n   * Used for the ghost only. The click that actually places a tag still raycasts: it is one pick,\n   * its cost does not matter, and it yields the surface normal, which depth alone cannot give.\n   */\n  private pickPointOnGpu(event: MouseEvent): THREE.Vector3 | null {\n    if (!this.modelRoot || !this.renderer || !this.camera) {\n      return null;\n    }\n\n    if (!this.pickTarget) {\n      this.pickTarget = new THREE.WebGLRenderTarget(1, 1);\n      this.pickCamera = new THREE.PerspectiveCamera();\n      this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);\n      this.pickDepthMaterial = new THREE.MeshDepthMaterial({\n        depthPacking: THREE.RGBADepthPacking,\n      });\n    }\n\n    const rect = this.renderer.domElement.getBoundingClientRect();\n    const x = event.clientX - rect.left;\n    const y = event.clientY - rect.top;\n    if (x < 0 || y < 0 || x > rect.width || y > rect.height) {\n      return null;\n    }\n\n    this.pickCamera.copy(this.camera);\n    this.pickCamera.layers.set(ThreeJsService.PICK_LAYER);\n    // Renders the one pixel the cursor is over as if it were the whole image - offset by half a\n    // pixel so the cursor sits at that pixel's centre, which is where NDC (0, 0) lands.\n    this.pickCamera.setViewOffset(rect.width, rect.height, x - 0.5, y - 0.5, 1, 1);\n\n    // Where the model is not, the pixel must read as \"nothing\", so it is cleared to white - a value\n    // no real depth packs to. Two things would otherwise paint over that: the default black clear,\n    // which decodes as depth 0 (a hit against the lens), and the scene background, which three.js\n    // draws in place of the clear colour whenever one is set.\n    const previousClearColor = this.renderer.getClearColor(new THREE.Color());\n    const previousClearAlpha = this.renderer.getClearAlpha();\n    const previousTarget = this.renderer.getRenderTarget();\n    const previousBackground = this.scene.background;\n\n    this.scene.background = null;\n    this.scene.overrideMaterial = this.pickDepthMaterial;\n    this.renderer.setClearColor(0xffffff, 1);\n    this.renderer.setRenderTarget(this.pickTarget);\n    this.renderer.clear();\n    this.renderer.render(this.scene, this.pickCamera);\n\n    this.renderer.readRenderTargetPixels(this.pickTarget, 0, 0, 1, 1, this.pickPixel);\n\n    this.renderer.setRenderTarget(previousTarget);\n    this.renderer.setClearColor(previousClearColor, previousClearAlpha);\n    this.scene.overrideMaterial = null;\n    this.scene.background = previousBackground;\n\n    const [r, g, b, a] = this.pickPixel;\n    if (r === 255 && g === 255 && b === 255 && a === 255) {\n      return null;\n    }\n\n    // The inverse of three's packDepthToRGBA, which stores the value itself in alpha and ever finer\n    // fractions of it in blue, green and red - alpha is the most significant byte, not red. Read the\n    // other way round, the result is mostly the low-order noise, often near zero, which unprojects\n    // onto the near plane: a ghost pressed against the lens, filling the whole screen.\n    const downscale = 255 / 256;\n    const depth =\n      (r / 255) * downscale / (256 * 256 * 256) +\n      (g / 255) * downscale / (256 * 256) +\n      (b / 255) * downscale / 256 +\n      (a / 255) * downscale;\n\n    // NDC x and y are zero because the pixel read is the centre of that one-pixel image - which only\n    // holds while the view offset is in effect. Clearing it first would unproject through the full\n    // view instead, landing the point on the ray through the middle of the screen. The offset is\n    // simply replaced by the next pick, so it is never cleared.\n    const world = new THREE.Vector3(0, 0, depth * 2 - 1).unproject(this.pickCamera);\n    this.tagGroup.updateWorldMatrix(true, false);\n    return this.tagGroup.worldToLocal(world);\n  }\n\n  private removePlacementPreview(): void {\n    if (!this.placementPreview) {\n      return;\n    }\n    this.tagGroup.remove(this.placementPreview);\n    this.placementPreview.material.map?.dispose();\n    this.placementPreview.material.dispose();\n    this.placementPreview = undefined;\n  }\n\n  /** Shows or hides one tag, leaving it registered so it can be brought back without reloading. */\n  setTagVisibility(elementId: string, visible: boolean): void {\n    const sprite = this.tagSprites.get(elementId);\n    if (sprite) {\n      sprite.visible = visible;\n    }\n  }\n\n  /**\n   * Shows only tags of the given types, hiding the rest.\n   *\n   * Passing null shows everything - the \"no filter\" state, distinct from an empty array, which is a\n   * filter that happens to match nothing.\n   */\n  setVisibleTagTypes(types: PoiType[] | null): void {\n    this.tagSprites.forEach((sprite) => {\n      sprite.visible = types === null || types.includes(sprite.userData.poiType);\n    });\n  }\n\n  /**\n   * Moves the camera to look at a tag, mirroring Matterport's goToTag.\n   *\n   * Animated rather than teleported: jumping the camera loses the viewer's sense of where they were\n   * relative to the model. The approach distance follows the model's size so it frames sensibly\n   * whatever the units are.\n   */\n  goToTag(elementId: string): void {\n    const sprite = this.tagSprites.get(elementId);\n    if (!sprite || !this.camera) {\n      return;\n    }\n\n    const target = sprite.getWorldPosition(new THREE.Vector3());\n    const distance = this.modelRoot\n      ? new THREE.Box3().setFromObject(this.modelRoot).getSize(new THREE.Vector3()).length() * 0.15\n      : 5;\n\n    // Approach along the current viewing direction, so the camera closes in rather than swinging\n    // around to an arbitrary side.\n    const direction = this.camera.position.clone().sub(this.controls.target).normalize();\n    this.cameraTween = {\n      fromPosition: this.camera.position.clone(),\n      toPosition: target.clone().add(direction.multiplyScalar(distance)),\n      fromTarget: this.controls.target.clone(),\n      toTarget: target,\n      startedAt: performance.now(),\n      durationMs: 600,\n    };\n  }\n\n  /** Advances the camera animation started by goToTag, if one is running. */\n  private stepCameraTween(): void {\n    if (!this.cameraTween) {\n      return;\n    }\n    const { fromPosition, toPosition, fromTarget, toTarget, startedAt, durationMs } = this.cameraTween;\n    const linear = Math.min((performance.now() - startedAt) / durationMs, 1);\n    // Ease out, so the move settles instead of stopping dead.\n    const t = 1 - Math.pow(1 - linear, 3);\n\n    this.camera.position.lerpVectors(fromPosition, toPosition, t);\n    this.controls.target.lerpVectors(fromTarget, toTarget, t);\n\n    if (linear >= 1) {\n      this.cameraTween = null;\n    }\n  }\n\n  isPlacingTag(): boolean {\n    return this.placingTag;\n  }\n\n  /** The spot picked by the last placement, for whoever commits it to a POI. */\n  getPendingTagPlacement(): ThreeJsTagPlacement | null {\n    return this.pendingTagPlacement;\n  }\n\n  /**\n   * Raycasts a click against the model's geometry and returns the hit, in world space.\n   *\n   * Returns null when the click missed, which is a normal outcome - the user clicked the sky - and\n   * leaves whatever mode is armed still armed, so they can simply try again.\n   */\n  private raycastModel(event: MouseEvent): THREE.Intersection | null {\n    if (!this.modelRoot) {\n      return null;\n    }\n\n    const rect = this.renderer.domElement.getBoundingClientRect();\n    this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\n    this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\n    this.raycaster.setFromCamera(this.mouse, this.camera);\n\n    return this.raycaster.intersectObject(this.modelRoot, true)[0] ?? null;\n  }\n\n  /**\n   * Turns a click into a point on the model, in the frame tag coordinates are persisted in.\n   *\n   * That frame is the tag group's, not the model's. A stored coordinate is read back as a sprite\n   * position inside that group, so a coordinate captured in any other frame comes back displaced by\n   * exactly however far the alignment moves the group. The two frames agree only while the\n   * alignment is identity, which is why this stayed invisible until a model was calibrated.\n   */\n  private pickPlacementOnModel(event: MouseEvent): ThreeJsTagPlacement | null {\n    const hit = this.raycastModel(event);\n    if (!hit) {\n      return null;\n    }\n\n    this.tagGroup.updateWorldMatrix(true, false);\n    const position = this.tagGroup.worldToLocal(hit.point.clone());\n\n    // A face normal is in the geometry's local space already, but the mesh it belongs to may sit\n    // under transforms of its own, so take it out through those and back into the tag frame, so it\n    // describes the same orientation the position does.\n    let normal = new THREE.Vector3(0, 1, 0);\n    if (hit.face) {\n      normal = hit.face.normal\n        .clone()\n        .transformDirection(hit.object.matrixWorld)\n        .transformDirection(new THREE.Matrix4().copy(this.tagGroup.matrixWorld).invert())\n        .normalize();\n    }\n\n    return {\n      position: { x: position.x, y: position.y, z: position.z },\n      normal: { x: normal.x, y: normal.y, z: normal.z },\n    };\n  }\n\n  /**\n   * Where the user says a tag really belongs, in the space the solved alignment maps onto.\n   *\n   * setTagAlignment writes the solution to the tag group's own transform, which is expressed\n   * relative to its parent - so the target has to be in the parent's frame. Measuring it in the\n   * group's own frame instead would fold the current alignment into the answer, making each\n   * calibration depend on the one before it.\n   */\n  private pickAlignmentTarget(event: MouseEvent): { x: number; y: number; z: number } | null {\n    const hit = this.raycastModel(event);\n    if (!hit) {\n      return null;\n    }\n    const frame = this.tagGroup.parent ?? this.scene;\n    frame.updateWorldMatrix(true, false);\n    const point = frame.worldToLocal(hit.point.clone());\n    return { x: point.x, y: point.y, z: point.z };\n  }\n\n  /**\n   * Sets the transform mapping captured tag coordinates onto this model's space.\n   *\n   * Every tag comes from the same source space, so this is one transform on the group rather than\n   * per-tag maths - which also means it applies retroactively to tags already placed, and can be\n   * adjusted live while someone dials the numbers in.\n   *\n   * Passing null resets to identity, i.e. tag coordinates are already in model space.\n   */\n  setTagAlignment(alignment: ThreeJsAlignment | null): void {\n    const { translation, rotation, scale } = alignment ?? {};\n    this.tagGroup.position.set(translation?.x ?? 0, translation?.y ?? 0, translation?.z ?? 0);\n    this.tagGroup.rotation.set(rotation?.x ?? 0, rotation?.y ?? 0, rotation?.z ?? 0);\n    this.tagGroup.scale.setScalar(scale ?? 1);\n\n    // Tag size is derived from the world scale it inherits, which this call just changed.\n    this.tagSprites.forEach((sprite) => this.scaleTagForModel(sprite));\n  }\n\n  /**\n   * Adds a tag, or moves/restyles the one already registered for this element.\n   *\n   * Upsert rather than a declarative \"here is the full list\" call, because tags arrive per type\n   * (equipment, then tickets, then measurements...) from separate subscriptions - replacing the set\n   * on each of those would wipe the types that came before.\n   */\n  upsertTag(tag: ThreeJsTag): void {\n    const existing = this.tagSprites.get(tag.id);\n    if (existing) {\n      existing.position.set(tag.position.x, tag.position.y, tag.position.z);\n      existing.userData.poiType = tag.poiType ?? existing.userData.poiType;\n      existing.userData.label = tag.label ?? existing.userData.label;\n      return;\n    }\n\n    const sprite = new THREE.Sprite(\n      new THREE.SpriteMaterial({\n        map: this.createTagTexture(tag.color),\n        // Tags read as UI rather than geometry, so they stay visible through the model instead of\n        // being occluded by whatever wall happens to be between them and the camera.\n        depthTest: false,\n        transparent: true,\n      })\n    );\n    sprite.name = tag.id;\n    sprite.userData.poiType = tag.poiType ?? null;\n    sprite.userData.label = tag.label ?? null;\n    sprite.position.set(tag.position.x, tag.position.y, tag.position.z);\n    sprite.renderOrder = 999;\n    this.scaleTagForModel(sprite);\n\n    this.tagGroup.add(sprite);\n    this.tagSprites.set(tag.id, sprite);\n\n    if (tag.iconUrl) {\n      this.applyTagIcon(sprite, tag.iconUrl);\n    }\n  }\n\n  /** Removes the tag registered for an element, if there is one. */\n  removeTag(elementId: string): void {\n    const sprite = this.tagSprites.get(elementId);\n    if (!sprite) {\n      return;\n    }\n    this.tagGroup.remove(sprite);\n    sprite.material.map?.dispose();\n    sprite.material.dispose();\n    this.tagSprites.delete(elementId);\n  }\n\n  /** Removes every tag from the scene. */\n  clearTags(): void {\n    [...this.tagSprites.keys()].forEach((id) => this.removeTag(id));\n  }\n\n  /** Loads an icon into an existing tag, leaving the fallback disc in place if it fails. */\n  private applyTagIcon(sprite: THREE.Sprite, iconUrl: string): void {\n    new THREE.TextureLoader().load(\n      iconUrl,\n      (texture) => {\n        sprite.material.map?.dispose();\n        sprite.material.map = texture;\n        sprite.material.needsUpdate = true;\n      },\n      undefined,\n      () => console.warn(`ThreeJsService: could not load tag icon \"${iconUrl}\", keeping the default marker.`)\n    );\n  }\n\n  /** Draws the default tag marker: a filled disc with a white ring, so it reads on any background. */\n  private createTagTexture(color = '#1E88E5'): THREE.CanvasTexture {\n    const size = 128;\n    const canvas = document.createElement('canvas');\n    canvas.width = size;\n    canvas.height = size;\n    const context = canvas.getContext('2d');\n\n    context.beginPath();\n    context.arc(size / 2, size / 2, size / 2 - 8, 0, Math.PI * 2);\n    context.fillStyle = color;\n    context.fill();\n    context.lineWidth = 8;\n    context.strokeStyle = '#FFFFFF';\n    context.stroke();\n\n    return new THREE.CanvasTexture(canvas);\n  }\n\n  /**\n   * Sizes a tag relative to the model.\n   *\n   * A sprite inherits the model's scale and the alignment's, so a fixed size would come out tiny on\n   * a large model and huge on a small one. Dividing by the group's world scale keeps tags the same\n   * size on screen whatever the model's units are.\n   */\n  private scaleTagForModel(sprite: THREE.Sprite): void {\n    const worldScale = this.tagGroup.getWorldScale(new THREE.Vector3()).x || 1;\n    const size = 0.4 / worldScale;\n    sprite.scale.set(size, size, 1);\n  }\n\n  /**\n   * Adds secondary interactive objects (e.g., POIs, sensors) to the scene.\n   */\n  updateObjsToScene(objsAdded: ObjAdded[]): void {\n    const existingIds = this.clickableObjects.map((obj) => obj.name);\n    const objLoader = new OBJLoader();\n\n    // delete objects that are not in the provided array\n    this.clickableObjects.forEach((obj) => {\n      if (!objsAdded.find((objData) => objData.id === obj.name)) {\n        this.scene.remove(obj);\n        this.clickableObjects = this.clickableObjects.filter(\n          (object) => object.name !== obj.name\n        );\n      }\n    });\n\n    objsAdded.forEach((objectData: ObjAdded) => {\n      if (!existingIds.includes(objectData.id)) {\n        objLoader.load(objectData.file, (newObject) => {\n          newObject.name = objectData.id;\n\n          newObject.traverse((child) => {\n            if ((child as THREE.Mesh).isMesh) {\n              const mesh = child as THREE.Mesh;\n              if (mesh.material instanceof THREE.Material) {\n                mesh.material.transparent = true;\n                mesh.material.opacity = 0.8;\n              }\n            }\n          });\n\n          // set object position and rotation\n          newObject.position.set(\n            objectData.position.x,\n            objectData.position.y,\n            objectData.position.z\n          );\n          \n          // The JSON configuration has rotation already in radians (e.g. 3.1415...)\n          newObject.rotation.set(\n            objectData.rotation.x,\n            objectData.rotation.y,\n            objectData.rotation.z\n          );\n\n          newObject.scale.set(objectData.scale.x, objectData.scale.y, objectData.scale.z);\n\n          this.scene.add(newObject);\n          this.clickableObjects.push(newObject);\n        });\n      }\n    });\n  }\n\n  private onMouseMove(event: MouseEvent): void {\n    if (!this.isDraggingCamera) {\n      const rect = this.renderer.domElement.getBoundingClientRect();\n      this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\n      this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\n\n      this.raycaster.setFromCamera(this.mouse, this.camera);\n\n      // While the ghost is up it follows the pointer and nothing else should react to it. The move\n      // is only recorded here: pointer events fire far more often than frames, and picking a point\n      // costs a raycast against the whole model, so doing it per event is what made the ghost trail\n      // behind the cursor. The render loop picks up the latest position, once, per frame.\n      if (this.isPreviewingPlacement()) {\n        this.pendingPreviewEvent = event;\n        return;\n      }\n\n      // Not previewing any more (a pair was just completed, say): drop a ghost left over from it.\n      this.removePlacementPreview();\n\n      // Tags first: they draw on top of the model, so they have to answer the pointer first too.\n      const hoveredTag = this.raycaster\n        .intersectObjects(this.tagGroup.children, false)\n        .find((hit) => hit.object.visible)?.object;\n      if (hoveredTag) {\n        this.renderer.domElement.style.cursor = 'pointer';\n        this.objectHovered$.next(null);\n        const label = hoveredTag.userData.label;\n        this.tagHovered$.next(label ? { label, event } : null);\n        return;\n      }\n      this.tagHovered$.next(null);\n\n      const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);\n\n      if (intersects.length > 0) {\n        this.renderer.domElement.style.cursor = 'pointer';\n        const intersectedObjectId = intersects[0].object?.parent?.name;\n        if (intersectedObjectId) {\n            this.objectHovered$.next({ id: intersectedObjectId, event });\n        }\n      } else {\n        this.renderer.domElement.style.cursor = 'default';\n        this.objectHovered$.next(null);\n      }\n    } else {\n      this.renderer.domElement.style.cursor = 'grabbing';\n      this.objectHovered$.next(null);\n    }\n  }\n\n  private onMouseClick(event: MouseEvent): void {\n    if (!this.isDraggingCamera) {\n      const rect = this.renderer.domElement.getBoundingClientRect();\n      this.mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;\n      this.mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;\n\n      // Alignment and placement both take the click before anything can be opened by it.\n      if (this.aligning) {\n        this.raycaster.setFromCamera(this.mouse, this.camera);\n        this.handleAlignmentClick(event);\n        return;\n      }\n\n      // Placement wins over everything: while armed, a click means \"put it here\", not \"open that\".\n      if (this.placingTag) {\n        const placement = this.pickPlacementOnModel(event);\n        if (placement) {\n          placement.poiType = this.placementPoiType;\n          this.pendingTagPlacement = placement;\n          this.placingTag = false;\n          this.removePlacementPreview();\n          this.renderer.domElement.style.cursor = 'default';\n          this.tagPlaced$.next(placement);\n        }\n        return;\n      }\n\n      this.raycaster.setFromCamera(this.mouse, this.camera);\n\n      // Same precedence as hover: a tag drawn over the model claims the click.\n      const tagHits = this.raycaster.intersectObjects(this.tagGroup.children, false)\n        .filter((hit) => hit.object.visible);\n      if (tagHits.length > 0) {\n        const tag = tagHits[0].object;\n        this.tagClicked$.next({ elementId: tag.name, poiType: tag.userData.poiType ?? null });\n        return;\n      }\n\n      const intersects = this.raycaster.intersectObjects(this.clickableObjects, true);\n\n      if (intersects.length > 0) {\n        const clickedObject = intersects[0].object;\n        const id = clickedObject?.parent?.name;\n        if (id) {\n            this.objectClicked$.next(id);\n        }\n      } else {\n        this.objectClicked$.next(null);\n      }\n    }\n  }\n\n  /**\n   * Escape cancels whatever the pointer is currently committed to.\n   *\n   * Emits through the same subjects the explicit Cancel buttons use, so the UI driving them follows\n   * along instead of being left showing a mode that is no longer armed.\n   */\n  private onKeyDown = (event: KeyboardEvent): void => {\n    if (event.key !== 'Escape') {\n      return;\n    }\n    if (this.placingTag) {\n      // Nothing outside the scene tracks placement, so clearing it here is the whole of it.\n      this.cancelTagPlacement();\n      return;\n    }\n    if (this.aligning) {\n      this.cancelTagAlignment();\n    }\n  }\n\n  private animate = (): void => {\n    this.animationFrameId = requestAnimationFrame(this.animate);\n    this.stepCameraTween();\n    this.controls.update();\n\n    // One pick per frame, against the pointer's latest position - see onMouseMove.\n    if (this.pendingPreviewEvent) {\n      const event = this.pendingPreviewEvent;\n      this.pendingPreviewEvent = null;\n      this.updatePlacementPreview(event);\n    }\n\n    this.renderer.render(this.scene, this.camera);\n  }\n\n  destroy(): void {\n    if (this.animationFrameId) {\n      cancelAnimationFrame(this.animationFrameId);\n    }\n    window.removeEventListener('keydown', this.onKeyDown);\n    if (this.canvasResizeObserver) {\n      this.canvasResizeObserver.disconnect();\n      this.canvasResizeObserver = undefined;\n    }\n    this.discardCurrentLoad();\n    this.clearTags();\n    if (this.renderer) {\n      this.renderer.dispose();\n    }\n    if (this.controls) {\n      this.controls.dispose();\n    }\n  }\n}\n"]}