@smarterplan/ngx-smarterplan-core 1.4.11 → 1.4.13

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

@@ -9,8 +9,8 @@ import * as i1$1 from '@angular/router';
 import { RouterModule } from '@angular/router';
 import { Matrix4, Vector3, Color, Object3D, Euler, PerspectiveCamera, CylinderBufferGeometry, BoxGeometry, MeshBasicMaterial, NormalBlending, BackSide, Mesh, EdgesGeometry, AdditiveBlending, ShaderMaterial, AnimationMixer, VectorKeyframeTrack, InterpolateSmooth, AnimationClip, LoopOnce, Group, PlaneBufferGeometry, CanvasTexture, Texture, LinearFilter } from 'three';
 import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { Auth, API, graphqlOperation, Storage, Cache } from 'aws-amplify';
 import { DateTime } from 'luxon';
-import { Auth, Storage, API, Cache } from 'aws-amplify';
 import * as i11 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import * as FileSaver from 'file-saver';
@@ -426,6 +426,14 @@ var SpModule;
     SpModule["HOTEL"] = "HOTEL";
     SpModule["IMMO"] = "IMMO";
 })(SpModule || (SpModule = {}));
+var MatterportViewType;
+(function (MatterportViewType) {
+    MatterportViewType["BASE"] = "viewtype.base";
+    MatterportViewType["DEFURNISH"] = "viewtype.defurnish";
+    MatterportViewType["LAYERED_BASE"] = "viewtype.layeredbase";
+    MatterportViewType["OTHER"] = "viewtype.other";
+    MatterportViewType["USER"] = "viewtype.user";
+})(MatterportViewType || (MatterportViewType = {}));
 
 /**
  * The base of all `SceneComponent` created with the sdk.
@@ -1901,14 +1909,14 @@ class PoiService {
         });
     }
     async getPoiByElementId(elementId) {
-        const pois = await this.API.__proto__.PoisByElement(elementId);
+        const pois = await this.API.PoisByElement(elementId);
         if (pois && pois.items.length > 0) {
             return pois.items[0];
         }
         return null;
     }
     async getPoisByType(type) {
-        return this.API.__proto__.PoisByType(type).then((pois) => pois.items);
+        return this.API.PoisByType(type).then((pois) => pois.items);
     }
     async createPOIForSpaceID(poi) {
         removeNullKeysFromObject(poi);
@@ -1930,23 +1938,100 @@ class PoiService {
                 // partitionKey: "",
             }, 'AWSKinesis');
         }
-        return this.API.__proto__.CreatePOI(poi);
+        return this.API.CreatePOI(poi);
     }
     poiIsVirtual(poi) {
         const { coordinate } = poi;
         return !coordinate;
     }
     async updatePoi(poi) {
-        return this.API.__proto__.UpdatePOI(poi);
+        return this.API.UpdatePOI(poi);
     }
     async deletePoi(poiID) {
-        return this.API.__proto__.DeletePOI({ id: poiID });
+        return this.API.DeletePOI({ id: poiID });
     }
     async getPoisByMatterportSweepByType(sweep, type) {
-        return this.API.__proto__
-            .ListPOIs({ matterportSweepID: { eq: sweep } }, 300)
+        return this.API.ListPOIS({ matterportSweepID: { eq: sweep } }, 300)
             .then((response) => response.items.filter((poi) => poi.type === type));
     }
+    /**
+    * Optimized version: fetches POIs for MANY sweeps in as few GraphQL calls as possible,
+    * using an `or: [{ matterportSweepID: { eq } }, ...]` filter instead of looping one
+    * request per sweep. This is a DynamoDB Scan with a server-side filter (not a GSI
+    * hash-key query), so `or` composition works and collapses N sweep-by-sweep calls
+    * into a handful of paginated calls total.
+    *
+    * NOTE: `in` is NOT supported on this schema's ModelStringInput (older Amplify codegen),
+    * hence the `or` composition instead — functionally equivalent for this use case.
+    *
+    * Chunked because DynamoDB/AppSync filter expressions have a practical size ceiling —
+    * splitting keeps each request well within safe limits regardless of space size.
+    */
+    async getPoisByMatterportSweeps(sweeps) {
+        if (!sweeps || sweeps.length === 0) {
+            return [];
+        }
+        const queryStatement = `
+    query ListPOISLight($filter: ModelPOIFilterInput, $limit: Int, $nextToken: String) {
+      listPOIS(filter: $filter, limit: $limit, nextToken: $nextToken) {
+        items {
+          id
+          coordinate
+          specific
+          private
+          global
+          type
+          elementID
+          level
+          role
+          category
+          domainID
+          metadata
+          tagIcon
+          tagDescription
+          tagImageID
+          matterportSweepID
+          createdAt
+          updatedAt
+        }
+        nextToken
+      }
+    }
+  `;
+        const CHUNK_SIZE = 50; // safe margin for an "or" filter expression's practical size
+        const chunks = [];
+        for (let i = 0; i < sweeps.length; i += CHUNK_SIZE) {
+            chunks.push(sweeps.slice(i, i + CHUNK_SIZE));
+        }
+        let allPois = [];
+        for (const chunk of chunks) {
+            let nextToken = null;
+            do {
+                const variables = {
+                    filter: {
+                        or: chunk.map((sweep) => ({ matterportSweepID: { eq: sweep } }))
+                    },
+                    limit: 1000,
+                    nextToken
+                };
+                try {
+                    const response = (await API.graphql(graphqlOperation(queryStatement, variables)));
+                    const resData = response.data.listPOIS;
+                    if (resData && resData.items.length > 0) {
+                        allPois = [...allPois, ...resData.items];
+                    }
+                    nextToken = resData?.nextToken ?? null;
+                }
+                catch (error) {
+                    // A failed page shouldn't abort the whole batch — log and stop paging this chunk only,
+                    // the rest of the copy process continues with whatever was already collected.
+                    console.error(`Error while fetching POIs for a sweep chunk:`, error);
+                    nextToken = null;
+                }
+            } while (nextToken);
+        }
+        return allPois;
+    }
     unsubscribe() {
         this.destroy$.next(true);
         this.destroy$.complete();
@@ -2367,6 +2452,9 @@ class MatterportNavigationService {
         else {
             console.warn('No matterport floor found to move to');
         }
+        console.log("action_go_to_floor.floorMatterport", floorMatterport);
+        console.log("action_go_to_floor.floorName", floorName);
+        console.log("action_go_to_floor.matterportFloorSequence", matterportFloorSequence);
     }
     /**
      * Navigate to a sweep. The caller can pass either a sid or a uuid;
@@ -2397,6 +2485,9 @@ class MatterportNavigationService {
                 await sdk.Camera.setRotation(rotation, { speed: 100 });
             }
         }, 1000);
+        console.log("action_go_to_sweep.sweep", sweep);
+        console.log("action_go_to_sweep.rotation", rotation);
+        console.log("action_go_to_sweep.resolvedSid", resolvedSid);
     }
     /**
      * Disable forbidden sweeps. Resolves each sweep ID to sid before calling SDK.
@@ -2416,6 +2507,130 @@ class MatterportNavigationService {
         }));
         console.log('removed sweeps:', removed);
     }
+    /**
+     * Move to a position
+     * @param sdk
+     * @param position
+     * @param rotation
+     * @param options
+     */
+    async move_to_position(sdk, position, rotation, options) {
+        // Validate SDK
+        if (!sdk) {
+            throw new Error('Matterport SDK instance is required');
+        }
+        // Merge options with defaults
+        const { transition = 'FLY', durationMs = 800, anglesInDegrees = true, offset = { x: 0, y: 0, z: 0 } } = options || {};
+        const degToRad = (d) => d * Math.PI / 180;
+        // Prepare rotation values (default to 0 when not provided)
+        const yaw = rotation?.yaw ?? 0;
+        const pitch = rotation?.pitch ?? 0;
+        const roll = rotation?.roll ?? 0;
+        // Convert to radians if angles are provided in degrees
+        const rotYaw = anglesInDegrees ? degToRad(yaw) : yaw;
+        const rotPitch = anglesInDegrees ? degToRad(pitch) : pitch;
+        const rotRoll = anglesInDegrees ? degToRad(roll) : roll;
+        // Preserve previous transition flag and mark as in-transition
+        const prevInTransition = this.inTransitionMode;
+        this.inTransitionMode = true;
+        try {
+            // Attempt to use Camera.lookAt when available
+            if (sdk?.Camera?.lookAt) {
+                const lookAtOpts = {};
+                // Prefer SDK constants when available, otherwise use fallback string
+                if (sdk.Camera.TransitionType && sdk.Camera.TransitionType[transition]) {
+                    lookAtOpts.transition = sdk.Camera.TransitionType[transition];
+                }
+                else {
+                    lookAtOpts.transition = transition;
+                }
+                lookAtOpts.duration = durationMs;
+                if (offset)
+                    lookAtOpts.offset = offset;
+                try {
+                    await sdk.Camera.lookAt(position, lookAtOpts);
+                }
+                catch (err) {
+                    // If lookAt fails, continue to fallbacks below
+                    if (isDevMode())
+                        console.debug('Camera.lookAt failed, falling back to setState', err);
+                }
+            }
+            // If lookAt is not present or failed, try setState for position
+            if (!sdk?.Camera?.lookAt && sdk?.Camera?.setState) {
+                const statePos = {
+                    position: { x: position.x, y: position.y, z: position.z }
+                };
+                try {
+                    await sdk.Camera.setState(statePos);
+                }
+                catch (err) {
+                    if (isDevMode())
+                        console.debug('Camera.setState(position) failed', err);
+                }
+            }
+            // Apply rotation if provided
+            if (rotation) {
+                // Prefer setRotation when available
+                if (sdk?.Camera?.setRotation) {
+                    // Try Vector2 signature { x: yaw, y: pitch } first
+                    try {
+                        await sdk.Camera.setRotation({ x: rotYaw, y: rotPitch }, { speed: Math.max(10, Math.floor(durationMs / 10)) });
+                    }
+                    catch (err1) {
+                        // If that fails, try Vector3 signature { x: pitch, y: yaw, z: roll }
+                        try {
+                            await sdk.Camera.setRotation({ x: rotPitch, y: rotYaw, z: rotRoll }, { speed: Math.max(10, Math.floor(durationMs / 10)) });
+                        }
+                        catch (err2) {
+                            if (isDevMode())
+                                console.debug('Camera.setRotation failed with multiple signatures', err1, err2);
+                            // Fallback to setState with rotation if available
+                            if (sdk?.Camera?.setState) {
+                                try {
+                                    await sdk.Camera.setState({
+                                        rotation: { x: rotPitch, y: rotYaw, z: rotRoll },
+                                        position: { x: position.x, y: position.y, z: position.z }
+                                    });
+                                }
+                                catch (err3) {
+                                    if (isDevMode())
+                                        console.debug('Fallback Camera.setState(rotation) failed', err3);
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (sdk?.Camera?.setState) {
+                    // If setRotation is not available, use setState to apply rotation
+                    try {
+                        await sdk.Camera.setState({
+                            rotation: { x: rotPitch, y: rotYaw, z: rotRoll },
+                            position: { x: position.x, y: position.y, z: position.z }
+                        });
+                    }
+                    catch (err) {
+                        if (isDevMode())
+                            console.debug('Camera.setState(rotation) failed', err);
+                    }
+                }
+                else {
+                    if (isDevMode())
+                        console.warn('No method available to apply rotation (setRotation/setState not found)');
+                }
+            }
+            // Wait a bit to allow transition animations to complete
+            await wait(durationMs + 120);
+        }
+        catch (err) {
+            // Re-throw after ensuring flags are restored in finally
+            throw err;
+        }
+        finally {
+            // Restore previous transition flag
+            this.inTransitionMode = prevInTransition;
+        }
+    }
     /**
      * Returns the current sweep as a **uuid** (for database matching).
      * The SDK's poseCamera.sweep is a sid; we translate it.
@@ -3200,6 +3415,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
 
 class MatterportTagService {
     navigationService;
+    /** Name of the common layer every Smarterplan tag is created in. */
+    static SHARED_TAG_LAYER_NAME = 'smarterplan-shared-tags';
     dictionnaryTags = new Map();
     tagAddQueue = Promise.resolve();
     mattertagToFollow = null;
@@ -3210,6 +3427,22 @@ class MatterportTagService {
     tagService = null;
     tagsCurrentOpacity = new Map();
     tagsCurrentEnabled = new Map();
+    /**
+     * Single layer holding every Smarterplan tag, added to every view of the space so a
+     * tag stays in place — same sid, same content — when the user switches between the
+     * furnished and the Defurnished view. Tags added to the global sdk.Tag (or to a
+     * view's own layer) belong to that view only, which is what made them pop in and out
+     * on every view change.
+     *
+     * Deliberately NOT created with `{ common: true }`: in SDK 26.7.5 a common layer is
+     * pushed into `getOrderedModelViews()` at creation time, and that call defaults to
+     * `includeDefurnish: false`, so the Defurnished view never receives it — while
+     * `View.addLayer()` refuses to repair it ("Layer is common. No need to add."). A
+     * plain layer we attach to each view ourselves reaches every view, Defurnished
+     * included. See attachSharedTagLayerToViews().
+     */
+    sharedTagLayer = null;
+    sharedTagLayerPromise = null;
     constructor(navigationService) {
         this.navigationService = navigationService;
     }
@@ -3222,6 +3455,7 @@ class MatterportTagService {
             return;
         try {
             this.onGoToTag.next(sid);
+            // `open` only exists on the global Tag module, never on a layer-scoped one.
             await sdk.Tag.open(sid);
         }
         catch (e) {
@@ -3229,6 +3463,102 @@ class MatterportTagService {
                 console.warn('Cannot open tag', sid, e);
         }
     }
+    /**
+     * Returns the SDK Tag module to use for an operation addressing an existing tag by ID
+     * (icon, opacity, position, attachments, removal...): always the global sdk.Tag.
+     *
+     * A layer-scoped Tag module only exposes the *replayable* mutations, meant to build
+     * the layer's own content; applying them to an already-created tag silently does
+     * nothing — which is what left every pin white instead of carrying its icon. Only
+     * `add` has to go through the layer, see getTagCreationModule().
+     */
+    getTagModule(sdk, tagId) {
+        return sdk?.Tag;
+    }
+    /**
+     * Returns the Tag module every new tag must be created through: the shared layer
+     * when the View API is available, the global sdk.Tag otherwise.
+     */
+    async getTagCreationModule(sdk) {
+        const layer = await this.ensureSharedTagLayer(sdk);
+        return layer?.Tag || sdk?.Tag;
+    }
+    /**
+     * Creates (once per SDK session) and returns the shared tag layer.
+     * Resolves to null when the View API is unavailable, so callers transparently fall
+     * back to the global sdk.Tag.
+     */
+    async ensureSharedTagLayer(sdk) {
+        if (this.sharedTagLayer)
+            return this.sharedTagLayer;
+        if (!sdk?.View?.createLayer)
+            return null;
+        if (!this.sharedTagLayerPromise) {
+            this.sharedTagLayerPromise = Promise.resolve(sdk.View.createLayer(MatterportTagService.SHARED_TAG_LAYER_NAME))
+                .then(async (layer) => {
+                this.sharedTagLayer = layer;
+                // A freshly created layer can come back toggled off, which hides its tags.
+                if (layer && layer.toggled === false) {
+                    await layer.toggle(true).catch(() => { });
+                }
+                return layer;
+            })
+                .catch((e) => {
+                // Allow a later retry (e.g. the SDK was not fully ready yet).
+                this.sharedTagLayerPromise = null;
+                if (isDevMode())
+                    console.warn('[MatterportTagService] Could not create the shared tag layer', e);
+                return null;
+            });
+        }
+        return this.sharedTagLayerPromise;
+    }
+    /**
+     * Makes sure the shared layer is part of every view of the space, Defurnished
+     * included. This is what actually shares the tags across views, and the reason the
+     * layer must not be a common one: the SDK only performs the attachment for
+     * non-common layers. Idempotent, so it can run on every view collection update.
+     */
+    async attachSharedTagLayerToViews(sdk, views) {
+        const layer = await this.ensureSharedTagLayer(sdk);
+        if (!layer)
+            return;
+        for (const view of views) {
+            if (!view?.addLayer || view.hasLayer?.(layer))
+                continue;
+            try {
+                await view.addLayer(layer);
+            }
+            catch (e) {
+                if (isDevMode())
+                    console.warn('[MatterportTagService] Cannot add the shared tag layer to view', view?.id, e);
+            }
+        }
+    }
+    /**
+     * Adds a tag through the shared layer so it exists in every view. Falls back
+     * to the global sdk.Tag when the View API is unavailable; that call is raced against
+     * a timeout as a safety net, since it never resolves while a Defurnished view is
+     * active.
+     */
+    async addTagToSdk(sdk, descriptor) {
+        const sharedTagModule = await this.getTagCreationModule(sdk);
+        try {
+            const sidList = (await Promise.race([
+                sharedTagModule.add(descriptor),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Tag.add timed out')), 4000)),
+            ]));
+            if (sidList?.length)
+                return sidList[0];
+        }
+        catch (error) {
+            if (error?.message?.includes('already in use'))
+                throw error;
+            if (isDevMode())
+                console.warn('[MatterportTagService] Tag.add failed/timed out', error?.message);
+        }
+        return null;
+    }
     /** Opens the most recently created tag in the viewer. */
     async goToLastTag(sdk) {
         if (!sdk || this.mattertagIDs.length === 0)
@@ -3243,30 +3573,40 @@ class MatterportTagService {
     async addMattertagToViewer(sdk, mattertagData) {
         if (!sdk)
             return null;
-        this.tagAddQueue = this.tagAddQueue.then(async () => {
-            const data = mattertagData.getData();
-            const existingId = data?.id || null;
+        this.tagAddQueue = this.tagAddQueue
+            .then(async () => {
+            const descriptor = mattertagData.getMattertagDescriptor()[0];
+            const existingId = descriptor?.id || null;
             try {
-                const sidList = await sdk.Tag.add(data);
-                if (sidList && sidList.length > 0) {
-                    const mattertagID = sidList[0];
-                    this.mattertagIDs.push(mattertagID);
-                    this.dictionnaryTags.set(mattertagID, mattertagData);
-                    return mattertagID;
+                const sid = await this.addTagToSdk(sdk, descriptor);
+                if (sid) {
+                    mattertagData.setMatterportSid(sid);
+                    if (!this.mattertagIDs.includes(sid)) {
+                        this.mattertagIDs.push(sid);
+                    }
+                    this.dictionnaryTags.set(sid, mattertagData);
+                    return sid;
                 }
+                if (isDevMode())
+                    console.warn('[MatterportTagService] Tag.add returned no sid', descriptor);
             }
             catch (error) {
                 if (error?.message?.includes('already in use') && existingId) {
                     if (!this.dictionnaryTags.has(existingId)) {
                         this.mattertagIDs.push(existingId);
-                        this.dictionnaryTags.set(existingId, mattertagData);
                     }
+                    this.dictionnaryTags.set(existingId, mattertagData);
                     return existingId;
                 }
                 if (isDevMode())
-                    console.warn('Failed to add tag to viewer', error);
+                    console.warn('[MatterportTagService] addMattertagToViewer failed', error);
             }
             return null;
+        })
+            .catch((e) => {
+            if (isDevMode())
+                console.warn('[MatterportTagService] tagAddQueue rejected', e);
+            return null;
         });
         return this.tagAddQueue;
     }
@@ -3285,7 +3625,8 @@ class MatterportTagService {
         }
         this.tagAddQueue = this.tagAddQueue.then(async () => {
             try {
-                const [createdSid] = await sdk.Tag.add(...descriptor);
+                const tagModule = await this.getTagCreationModule(sdk);
+                const [createdSid] = await tagModule.add(...descriptor);
                 this.mattertagIDs.push(createdSid);
                 this.dictionnaryTags.set(createdSid, mattertagData);
                 await wait(100);
@@ -3332,36 +3673,6 @@ class MatterportTagService {
                 tagPos.z >= min.z - margin && tagPos.z <= max.z + margin);
         });
     }
-    /**
-     * Computes the final context-aware opacity for a single tag.
-     * @param currentFloorSequence  Authoritative current floor sequence from sdk.Floor.current
-     *                              (null = single-floor model or unknown).
-     * @param currentRooms          Array of active rooms the camera is in.
-     */
-    /*computeSingleTagContextOpacity(
-      mattertagData: MattertagData,
-      poseCamera: any,
-      sweepCollection: any,
-      currentFloorSequence: number | null,
-      currentRooms: any[]
-    ): number {
-      const mode = this.navigationService.currentCameraMode;
-  
-      // 1. Check Floor
-      const tagFloorId = this.getFloorIdForTag(mattertagData, sweepCollection);
-      const currentFloorId = currentFloorSequence?.toString();
-      if (tagFloorId && currentFloorId && tagFloorId !== currentFloorId) {
-        return 0;
-      }
-  
-      // 2. Si Dollhouse -> Pleine opacité
-      //if (mode !== CameraMode.INSIDE) return 1;
-  
-      // 3. Si Inside -> Check pièce + Distance progressive
-      //if (!this.isTagInRooms(mattertagData, currentRooms)) return 0;
-  
-      return 1;
-    }*/
     /** Returns the ID of the most recently added tag. */
     getLastTag() {
         if (this.mattertagIDs.length === 0)
@@ -3411,10 +3722,11 @@ class MatterportTagService {
             }
             // Apply changes
             // Tooltip and click management
+            const tagModule = this.getTagModule(sdk, tagId);
             const lastEnabled = this.tagsCurrentEnabled.get(tagId);
             if (lastEnabled !== shouldBeEnabled) {
                 this.tagsCurrentEnabled.set(tagId, shouldBeEnabled);
-                promises.push(sdk.Tag.allowAction(tagId, {
+                promises.push(tagModule.allowAction(tagId, {
                     opening: shouldBeEnabled,
                     navigating: shouldBeEnabled,
                     docking: false
@@ -3424,16 +3736,26 @@ class MatterportTagService {
             const lastOpacity = this.tagsCurrentOpacity.get(tagId) ?? -1;
             if (Math.abs(lastOpacity - targetOpacity) > 0.05) {
                 this.tagsCurrentOpacity.set(tagId, targetOpacity);
-                promises.push(sdk.Tag.editOpacity(tagId, targetOpacity).catch(() => { }));
+                promises.push(tagModule.editOpacity(tagId, targetOpacity).catch(() => { }));
             }
         }
         await Promise.all(promises);
     }
+    /**
+     * Drops the memoized opacity/enabled state so the next visibility pass re-applies it
+     * to every tag. Needed after a view switch (furnished <-> defurnished): the SDK
+     * re-renders the shared layer's tags and the cached values would otherwise make
+     * updateTagsVisibilityForContext() skip them, leaving tags stuck invisible.
+     */
+    resetVisibilityCache() {
+        this.tagsCurrentOpacity.clear();
+        this.tagsCurrentEnabled.clear();
+    }
     /** Removes a specific tag from the viewer and local dictionaries. */
     async deleteMattertagFromId(sdk, mattertagID) {
         try {
             if (sdk)
-                await sdk.Tag.remove(mattertagID);
+                await this.getTagModule(sdk, mattertagID).remove(mattertagID);
             this.dictionnaryTags.delete(mattertagID);
             const index = this.mattertagIDs.indexOf(mattertagID);
             if (index > -1)
@@ -3456,7 +3778,7 @@ class MatterportTagService {
             const sidsToRemove = [...this.mattertagIDs];
             for (const sid of sidsToRemove) {
                 try {
-                    await sdk.Tag.remove(sid);
+                    await this.getTagModule(sdk, sid).remove(sid);
                 }
                 catch (e) { }
             }
@@ -3467,7 +3789,7 @@ class MatterportTagService {
      * Creates and configures a Mattertag from a POI, handling coordinates, normals, and sweep ID.
      * Skips creation if a tag for the object already exists.
      */
-    async createMattertagFromPOI(sdk, tagType, object, poi, poseCamera, getTagFromElementId, setTagIconAndOpacity, injectHtmlInTag) {
+    async createMattertagFromPOI(sdk, tagType, object, poi, getTagFromElementId, setTagIconAndOpacity, injectHtmlInTag) {
         const { tag } = getTagFromElementId(object.id);
         if (tag)
             return;
@@ -3496,6 +3818,12 @@ class MatterportTagService {
         }
         mattertagData.setPoi(poi);
         const createdTagID = await this.addMattertagToViewer(sdk, mattertagData);
+        console.log('---------------');
+        console.log('element id ' + mattertagData.elementID);
+        console.log('position: ', mattertagData.getPosition());
+        console.log('rotation: ', mattertagData.getRotation());
+        console.log('sweep id: ', mattertagData.getSweepID());
+        console.log('---------------');
         if (createdTagID && sdk) {
             await wait(100);
             await setTagIconAndOpacity(createdTagID, mattertagData);
@@ -3523,10 +3851,11 @@ class MatterportTagService {
             return;
         try {
             const iconName = `custom-icon-${mattertagID}`;
+            const tagModule = this.getTagModule(sdk, mattertagID);
             await sdk.Asset.registerTexture(iconName, iconPath);
-            await sdk.Tag.editIcon(mattertagID, iconName);
+            await tagModule.editIcon(mattertagID, iconName);
             if (applyOpacity) {
-                await sdk.Tag.editOpacity(mattertagID, opacity);
+                await tagModule.editOpacity(mattertagID, opacity);
             }
         }
         catch (error) {
@@ -3590,16 +3919,17 @@ class MatterportTagService {
             if (html && html.trim().length > 0 && sdk) {
                 const scriptTag = this.tagService.getScriptForTag(object, tagType);
                 html += `${scriptTag}`;
+                const tagModule = this.getTagModule(sdk, tagID);
                 const [sandboxId, messenger] = await sdk.Tag.registerSandbox(html);
                 const attachmentID = this.tagsAttachments[tagID];
                 if (attachmentID) {
                     try {
-                        await sdk.Tag.detach(tagID, attachmentID);
+                        await tagModule.detach(tagID, attachmentID);
                     }
                     catch (e) { }
                 }
                 this.tagsAttachments[tagID] = sandboxId;
-                await sdk.Tag.attach(tagID, sandboxId);
+                await tagModule.attach(tagID, sandboxId);
                 // Attach the "View informations" handler in tooltip
                 messenger.on(TagAction.DETAIL_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
                 messenger.on(TagAction.TICKET_CLICK, this.tagService.onActionDetailClick.bind(this.tagService));
@@ -3612,11 +3942,12 @@ class MatterportTagService {
             else if (sdk) {
                 const { comment, tagDescription } = this.tagService.getBillboardMediaToEmbed(object);
                 if (comment) {
+                    const tagModule = this.getTagModule(sdk, tagID);
                     // 1) Register the media attachment by passing the URL string(s).
                     //    registerAttachment returns an array of attachment IDs.
                     const [attachmentID] = await sdk.Tag.registerAttachment(comment.externalLink);
                     // 2) Attach the registered media to the tag.
-                    await sdk.Tag.attach(tagID, attachmentID);
+                    await tagModule.attach(tagID, attachmentID);
                     // 3) Determine media type for the billboard (PHOTO or VIDEO).
                     //    Use a simple heuristic: YouTube/Vimeo -> VIDEO, otherwise PHOTO.
                     //    The SDK exposes MediaType on the Tag namespace.
@@ -3624,7 +3955,7 @@ class MatterportTagService {
                     const mediaType = isVideo ? sdk.Mattertag.MediaType.VIDEO : sdk.Mattertag.MediaType.PHOTO;
                     // 4) Update the billboard text and media using editBillboard.
                     //    editBillboard accepts Partial<Tag.EditableProperties> such as label, description, media.
-                    await sdk.Tag.editBillboard(tagID, {
+                    await tagModule.editBillboard(tagID, {
                         label: object.title || 'Media',
                         description: tagDescription || '',
                         media: {
@@ -3650,9 +3981,14 @@ class MatterportTagService {
     /** Clears all local tag data and resets the addition queue. */
     clear() {
         this.dictionnaryTags.clear();
+        this.tagsCurrentOpacity.clear();
+        this.tagsCurrentEnabled.clear();
         this.tagAddQueue = Promise.resolve();
         this.mattertagToFollow = null;
         this.mattertagIDs = [];
+        // A new space means a new SDK session, hence a new shared layer to create.
+        this.sharedTagLayer = null;
+        this.sharedTagLayerPromise = null;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, deps: [{ token: MatterportNavigationService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagService, providedIn: 'root' });
@@ -3768,6 +4104,15 @@ class MatterportService {
         this.navigationService.forbiddenSweeps = value;
     }
     tagAction = new Subject();
+    /** Views (furnished, defurnished...) exposed by the SDK for the current space. */
+    viewsByType = new Map();
+    currentView = null;
+    viewSubscriptions = [];
+    /** Emits the active view every time the user switches between furnished/defurnished. */
+    onViewChanged = new Subject();
+    /** Delay left to the SDK to rebuild the layer's tags after a view switch. */
+    static VIEW_SWITCH_REFRESH_DELAY_MS = 800;
+    viewSwitchRestoreTimer = null;
     get mattertagToFollow() {
         return this.matterportTagService.mattertagToFollow;
     }
@@ -3923,7 +4268,9 @@ class MatterportService {
                     default:
                         break;
                 }
-                this.sdk.Asset.registerTexture('icon-position', this.config.my_config.icon_position);
+                this.sdk.Asset.registerTexture('icon-position', this.config.my_config.icon_position)
+                    .catch((e) => { if (isDevMode())
+                    console.warn('icon-position texture registration failed', e); });
                 // Current Room (used for getting bounding box and eventually lazy load mattertag or object3D inside current Room)
                 this.sdk.Room.current.subscribe((currentRoom) => {
                     const rooms = Array.isArray(currentRoom) ? currentRoom : (currentRoom ? [currentRoom] : []);
@@ -4021,8 +4368,9 @@ class MatterportService {
                     if (!this.sdk || sid === this.mattertagToFollow)
                         return; // ignore when we are in positioning mode
                     try {
-                        if (this.sdk.Tag?.allowAction) {
-                            this.sdk.Tag.allowAction(sid, { opening: true, navigating: true, docking: false });
+                        const tagModule = this.matterportTagService.getTagModule(this.sdk, sid);
+                        if (tagModule?.allowAction) {
+                            tagModule.allowAction(sid, { opening: true, navigating: true, docking: false });
                         }
                     }
                     catch (e) {
@@ -4034,7 +4382,11 @@ class MatterportService {
                 };
                 // Wait for the application to reach PLAYING phase
                 if (this.sdk.App && this.sdk.App.state) {
-                    this.sdk.App.state.waitUntil((s) => s.phase === this.sdk.App.Phase.PLAYING).then(() => {
+                    this.sdk.App.state.waitUntil((s) => s.phase === this.sdk.App.Phase.PLAYING).then(async () => {
+                        // Create the common layer holding every tag before any tag is added, so that
+                        // tags are shared between the furnished and the defurnished views.
+                        await this.matterportTagService.ensureSharedTagLayer(this.sdk);
+                        this.initViews();
                         this.sdk.Camera.pose.subscribe((pose) => {
                             this.poseCamera = pose;
                             this.matterportTagService.updateTagsVisibilityForContext(this.sdk, this.sweepCollection, this.navigationService.currentCameraMode, this.mattertagToFollow, this.navigationService.currentFloorSequence, this.navigationService.currentRooms);
@@ -4174,7 +4526,7 @@ class MatterportService {
      */
     enable_following_tag(mattertag) {
         const OFFSET = 0.0001; // quasi-invisible mais suffit à éviter l'interception
-        this.sdk.Tag.editPosition(mattertag, {
+        this.matterportTagService.getTagModule(this.sdk, mattertag).editPosition(mattertag, {
             anchorPosition: {
                 x: this.poseMatterport.position.x + OFFSET,
                 y: this.poseMatterport.position.y,
@@ -4201,28 +4553,42 @@ class MatterportService {
     //
     /** Creates a temporary Mattertag that follows the user's cursor for positioning. */
     async addCursorMattertag(mattertagData) {
+        if (!this.poseMatterport && this.poseCamera) {
+            this.poseMatterport = {
+                position: { ...this.poseCamera.position },
+                normal: { x: 0, y: -0.15, z: 0 },
+                time: new Date().getTime()
+            };
+        }
         if (!this.poseMatterport)
             return;
         this.mattertagToFollow = await this.addMattertagToViewer(mattertagData);
+        if (!this.mattertagToFollow) {
+            if (isDevMode())
+                console.warn('addCursorMattertag: tag creation failed, mattertagToFollow is null');
+            return;
+        }
         await wait(50);
-        this.sdk.Tag.editIcon(this.mattertagToFollow, 'icon-position');
-        this.sdk.Tag.editOpacity(this.mattertagToFollow, 1);
-        this.sdk.Tag.editPosition(this.mattertagToFollow, {
-            anchorPosition: { ...this.poseMatterport.position },
-            stemVector: {
-                x: this.poseMatterport.normal.x * 0.3,
-                y: this.poseMatterport.normal.y * 0.3,
-                z: this.poseMatterport.normal.z * 0.3,
-            }
-        });
+        const tagModule = this.matterportTagService.getTagModule(this.sdk, this.mattertagToFollow);
         try {
-            await this.sdk.Tag.allowAction(this.mattertagToFollow, {
-                opening: true,
-                navigating: false,
-                docking: false
+            await tagModule.editIcon(this.mattertagToFollow, 'icon-position');
+            await tagModule.editOpacity(this.mattertagToFollow, 1);
+            await tagModule.editPosition(this.mattertagToFollow, {
+                anchorPosition: { ...this.poseMatterport.position },
+                stemVector: {
+                    x: (this.poseMatterport.normal?.x ?? 0) * 0.3,
+                    y: (this.poseMatterport.normal?.y ?? -0.15) * 0.3,
+                    z: (this.poseMatterport.normal?.z ?? 0) * 0.3,
+                }
+            });
+            await tagModule.allowAction(this.mattertagToFollow, {
+                opening: true, navigating: false, docking: false
             });
         }
-        catch (e) { }
+        catch (e) {
+            if (isDevMode())
+                console.warn('addCursorMattertag: error configuring cursor tag', e);
+        }
     }
     get tagAddQueue() {
         return this.matterportTagService.tagAddQueue;
@@ -4251,7 +4617,7 @@ class MatterportService {
     /** Applies a pre-registered icon to a Mattertag. */
     async setRegistredIconForTag(mattertagID, iconName) {
         try {
-            this.sdk.Tag.editIcon(mattertagID, iconName);
+            this.matterportTagService.getTagModule(this.sdk, mattertagID).editIcon(mattertagID, iconName);
         }
         catch (e) {
             if (isDevMode())
@@ -4269,7 +4635,7 @@ class MatterportService {
             else {
                 iconName = `${iconName}_unavailable`;
             }
-            this.sdk.Tag.editIcon(mattertagID, iconName);
+            await this.editTagIcon(mattertagID, iconName);
             return;
         }
         const stringTagType = poiTypeToString(mattertagData.getType());
@@ -4301,11 +4667,19 @@ class MatterportService {
                 opacity = tagIcon.opacity;
             }
         }
+        await this.editTagIcon(mattertagID, iconName);
+    }
+    /**
+     * Applies an icon to a tag. The call is awaited and its rejection reported: a
+     * silently dropped promise here leaves the pin with its default white look.
+     */
+    async editTagIcon(mattertagID, iconName) {
         try {
-            this.sdk.Tag.editIcon(mattertagID, iconName);
+            await this.matterportTagService.getTagModule(this.sdk, mattertagID).editIcon(mattertagID, iconName);
         }
         catch (error) {
-            console.log('Error editIcon or opacity', error);
+            if (isDevMode())
+                console.warn('[MatterportService] editIcon failed for', mattertagID, iconName, error);
         }
     }
     /** Navigates the camera to the most recently created tag. */
@@ -4326,18 +4700,60 @@ class MatterportService {
                 await this.sdk.Camera.lookAt(position, {
                     transition: this.sdk.Camera.TransitionType.FLY
                 });
-                await this.sdk.Tag.open(mattertagID);
-            }
-            else {
-                // Fallback for cases where we don't have local data yet
-                await this.sdk.Tag.open(mattertagID);
             }
+            // `open` only exists on the global Tag module, never on a layer-scoped one.
+            await this.sdk.Tag.open(mattertagID);
         }
         catch (error) {
             if (isDevMode())
                 console.warn('Cannot navigate to tag', error);
         }
     }
+    /**
+     * Move the viewer camera to a specific 3D position and apply a rotation.
+     * Delegates the heavy lifting to MatterportNavigationService.move_to_position.
+     * - position: { x, y, z }
+     * - rotation: { yaw, pitch?, roll? } in degrees by default
+     * - options: optional transition and conversion settings (see navigation service)
+     */
+    async goToPosition(position, rotation = null, options) {
+        // Ensure SDK is initialized
+        if (!this.sdk) {
+            throw new Error('Matterport SDK is not initialized');
+        }
+        // Prevent concurrent navigation if already in a sweep/mode transition
+        if (this.inTransitionMode || this.inTransitionSweep) {
+            if (isDevMode())
+                console.debug('goToPosition aborted: viewer is in transition');
+            return;
+        }
+        try {
+            // Mark transition state on navigation service (move_to_position will also manage flags)
+            this.inTransitionMode = true;
+            // Delegate to navigation service which contains the robust move_to_position implementation
+            await this.navigationService.move_to_position(this.sdk, position, rotation, options);
+            // Update local cached camera info
+            this.lastCameraPosition = { ...position };
+            // Emit a simplified current camera pose for subscribers
+            this.currentCameraPose.next({
+                position: { ...position },
+                rotation: rotation ? { ...rotation } : null,
+                sweep: this.poseCamera?.sweep ?? null
+            });
+            if (isDevMode()) {
+                console.debug('goToPosition completed', { position, rotation, options });
+            }
+        }
+        catch (err) {
+            if (isDevMode())
+                console.error('goToPosition error', err);
+            throw err;
+        }
+        finally {
+            // Ensure transition flag is cleared (navigation service may also clear it)
+            this.inTransitionMode = false;
+        }
+    }
     /**
       * Computes the context-aware opacity for a single tag at the moment it is rendered.
       * - Cursor tag: always use provided defaultOpacity.
@@ -4370,6 +4786,9 @@ class MatterportService {
       .logo-link,
       .footer-logo,
       .bottom-ui,
+      img.logo-image,
+      img[class^="logo-image"],
+      img[class*=" logo-image"],
       [data-testid="showcase-footer"] {
         opacity: 0 !important;
         visibility: hidden !important;
@@ -4396,7 +4815,7 @@ class MatterportService {
      */
     async updateMatterTagContentForTagID(mattertagID, object = null, tagType = null) {
         if (this.sdk) {
-            await this.sdk.Tag.editBillboard(mattertagID, this.dictionnaryTags.get(mattertagID).getData());
+            await this.matterportTagService.getTagModule(this.sdk, mattertagID).editBillboard(mattertagID, this.dictionnaryTags.get(mattertagID).getData());
         }
         // Mise à jour de l'icône immédiate
         await this.matterportTagService.updateMatterTagContentForTagID(this.sdk, mattertagID, object, tagType, this.setTagIconAndOpacity.bind(this), 
@@ -4439,7 +4858,7 @@ class MatterportService {
      * @returns
      */
     async createMattertagFromPOI(tagType, object, poi) {
-        return this.matterportTagService.createMattertagFromPOI(this.sdk, tagType, object, poi, this.poseCamera, this.getTagFromElementId.bind(this), this.setTagIconAndOpacity.bind(this), this.injectHtmlInTag.bind(this));
+        return this.matterportTagService.createMattertagFromPOI(this.sdk, tagType, object, poi, this.getTagFromElementId.bind(this), this.setTagIconAndOpacity.bind(this), this.injectHtmlInTag.bind(this));
     }
     /**
      * Inject custom HTML as Mattertag content
@@ -4504,6 +4923,10 @@ class MatterportService {
         const mattertagData = new MattertagData(poiType);
         mattertagData.setSweepID(this.navigationService.resolveSweepUuid(this.poseCamera.sweep));
         mattertagData.setRotation(this.poseCamera.rotation);
+        const initialPosition = this.poseMatterport?.position ?? this.poseCamera.position;
+        const initialNormal = this.poseMatterport?.normal ?? { x: 0, y: -0.15, z: 0 };
+        mattertagData.setPosition({ ...initialPosition });
+        mattertagData.setNormal({ ...initialNormal });
         this.setInteractionMode(ViewerInteractions.ADDING);
         await this.addCursorMattertag(mattertagData);
     }
@@ -4621,8 +5044,14 @@ class MatterportService {
         }
     }
     async updateMatterTagPosInSdkViewer(mattertagID, object, poiType, poi = null) {
-        const IndexToUpdate = object.pois.items.findIndex((u) => u.id === poi.id);
-        object.pois.items[IndexToUpdate] = poi;
+        if (!poi || !poi.coordinate) {
+            console.warn('updateMatterTagPosInSdkViewer: poi or poi.coordinate is missing', poi);
+            return;
+        }
+        const IndexToUpdate = object.pois?.items ? object.pois.items.findIndex((u) => u?.id === poi.id) : -1;
+        if (IndexToUpdate !== -1 && object.pois?.items) {
+            object.pois.items[IndexToUpdate] = poi;
+        }
         const { x, y, z } = JSON.parse(poi.coordinate);
         const newPosition = {
             anchorPosition: {
@@ -4637,8 +5066,7 @@ class MatterportService {
                 z: 0,
             },
         };
-        //this.sdk.Mattertag.editPosition(mattertagID, newPosition);
-        this.sdk.Tag.editPosition(mattertagID, newPosition);
+        this.matterportTagService.getTagModule(this.sdk, mattertagID).editPosition(mattertagID, newPosition);
         this.dictionnaryTags
             .get(mattertagID)
             .setPosition(newPosition.anchorPosition);
@@ -4648,8 +5076,7 @@ class MatterportService {
                 continue;
             }
             if (currentTag.elementID === object.id && tagId !== mattertagID) {
-                this.dictionnaryTags.delete(tagId);
-                this.sdk.Tag.remove(tagId);
+                await this.matterportTagService.deleteMattertagFromId(this.sdk, tagId);
                 break;
             }
         }
@@ -4691,6 +5118,140 @@ class MatterportService {
         return null;
     }
     //
+    // ---------- Views (furnished / defurnished) ----------
+    //
+    /**
+     * Subscribes to the SDK View API to keep track of the views available for the space
+     * and of the active one. Tags live in a shared common layer, so a view change only
+     * requires re-applying their visibility, never re-creating them.
+     */
+    initViews() {
+        this.clearViewSubscriptions();
+        this.viewsByType.clear();
+        this.currentView = null;
+        if (!this.sdk?.View?.views) {
+            if (isDevMode())
+                console.warn('[MatterportService] View API unavailable on this SDK version');
+            return;
+        }
+        this.viewSubscriptions.push(this.sdk.View.views.subscribe({
+            onCollectionUpdated: (collection) => {
+                // SDK callbacks run outside Angular: re-enter the zone so the views made
+                // available here (defurnish button...) are picked up by change detection.
+                this.ngZone.run(() => {
+                    this.viewsByType.clear();
+                    for (const view of Object.values(collection)) {
+                        this.viewsByType.set(view.type, view);
+                    }
+                });
+                // Views are discovered progressively: make sure each one carries the shared
+                // tag layer, otherwise its tags would not exist in that view.
+                this.matterportTagService.attachSharedTagLayerToViews(this.sdk, Object.values(collection));
+            },
+        }));
+        this.viewSubscriptions.push(this.sdk.View.current.subscribe((view) => {
+            const changed = this.currentView?.id !== view?.id;
+            this.currentView = view;
+            if (!changed)
+                return;
+            this.restoreTagsForActiveView(view);
+            this.ngZone.run(() => this.onViewChanged.next(view));
+        }));
+    }
+    /**
+     * Forces the opacity/enabled state to be pushed again to every tag. The SDK
+     * re-renders the shared layer's tags on a view swap, and the memoized values would
+     * otherwise make updateTagsVisibilityForContext() skip them, leaving tags invisible.
+     */
+    reapplyTagsVisibility() {
+        this.matterportTagService.resetVisibilityCache();
+        this.refreshTagsVisibility();
+    }
+    /**
+     * Puts the tags back in shape in the view that just became active.
+     *
+     * Activating a view re-materializes the shared layer's tags from the descriptors
+     * recorded when they were added, so everything applied to a tag *afterwards* through
+     * the global Tag module is dropped along the way: the custom icon (the pin falls back
+     * to the descriptor's white) and the sandbox carrying the hover content. They have to
+     * be applied again on the freshly rebuilt tags.
+     *
+     * Visibility is refreshed straight away so the tags show up without waiting, then
+     * content is re-applied once the transition is over — re-applying it too early would
+     * target tags the SDK has not rebuilt yet.
+     */
+    restoreTagsForActiveView(view) {
+        // A view only materializes its layers once activated: (re)attach the shared one.
+        this.matterportTagService.attachSharedTagLayerToViews(this.sdk, [view])
+            .then(() => this.reapplyTagsVisibility());
+        this.reapplyTagsVisibility();
+        clearTimeout(this.viewSwitchRestoreTimer);
+        this.viewSwitchRestoreTimer = setTimeout(() => {
+            this.refreshTagsContent()
+                .catch((e) => {
+                if (isDevMode())
+                    console.warn('[MatterportService] Cannot restore tags for view', view?.id, e);
+            })
+                .then(() => this.reapplyTagsVisibility());
+        }, MatterportService.VIEW_SWITCH_REFRESH_DELAY_MS);
+    }
+    /**
+     * Re-applies the icon and the injected HTML of every tag we own. Used after a view
+     * switch, see restoreTagsForActiveView().
+     */
+    async refreshTagsContent() {
+        if (!this.sdk)
+            return;
+        // Snapshot: the dictionary can be mutated while the awaits below are pending.
+        for (const [sid, mattertagData] of [...this.dictionnaryTags]) {
+            if (sid === this.mattertagToFollow)
+                continue;
+            await this.setTagIconAndOpacity(sid, mattertagData);
+            this.injectHtmlInTag(mattertagData.getType(), mattertagData.getObject(), sid)
+                .catch((err) => {
+                if (isDevMode())
+                    console.warn('[MatterportService] HTML re-injection failed for', sid, err);
+            });
+        }
+    }
+    clearViewSubscriptions() {
+        clearTimeout(this.viewSwitchRestoreTimer);
+        this.viewSwitchRestoreTimer = null;
+        for (const subscription of this.viewSubscriptions) {
+            try {
+                subscription.cancel();
+            }
+            catch (e) {
+                if (isDevMode())
+                    console.warn('[MatterportService] Cannot cancel view subscription', e);
+            }
+        }
+        this.viewSubscriptions = [];
+    }
+    /** True when the space provides a defurnished view. */
+    get hasDefurnishView() {
+        return this.viewsByType.has(MatterportViewType.DEFURNISH);
+    }
+    /** True when the defurnished view is the active one. */
+    get isDefurnishedView() {
+        return this.currentView?.type === MatterportViewType.DEFURNISH;
+    }
+    /**
+     * Switches between the defurnished view and the furnished one.
+     * @param returnToStart Move the camera back to the view's start location.
+     */
+    async toggleDefurnishView(returnToStart = false) {
+        const target = this.isDefurnishedView
+            ? this.viewsByType.get(MatterportViewType.LAYERED_BASE) ?? this.viewsByType.get(MatterportViewType.BASE)
+            : this.viewsByType.get(MatterportViewType.DEFURNISH);
+        if (!target) {
+            if (isDevMode())
+                console.warn('[MatterportService] No target view to switch to');
+            return;
+        }
+        await target.setActive(returnToStart);
+    }
+    //
     // ---------- Viewer related (switch views, go to) ----------
     //
     async action_toolbox_floorplan() {
@@ -4742,6 +5303,9 @@ class MatterportService {
      */
     async clearAll() {
         console.log('removing viewer');
+        this.clearViewSubscriptions();
+        this.viewsByType.clear();
+        this.currentView = null;
         await this.action_delete_all_mattertags();
         this.floors = null;
         this.sweeps = null;
@@ -4989,6 +5553,13 @@ class ViewerService {
                 await this.actionAddObjectFromPOI(object, poi);
             }
         }));
+        // Newly created tags have no opacity/allowAction applied yet (only set by
+        // updateTagsVisibilityForContext, which runs on Mode/Sweep/Floor/Room/Camera
+        // events). If this batch loaded after those fired, the tags stay in whatever
+        // default state the SDK gave them until something else nudges a refresh.
+        if (this.checkMode('Matterport')) {
+            this.matterportService.refreshTagsVisibility();
+        }
     }
     async actionAddObjectFromPOI(object, poi) {
         if (this.checkMode('Matterport')) {
@@ -5418,6 +5989,17 @@ const uploadJsonToS3 = async (path, json, filename) => {
         return null;
     });
 };
+/**
+ * Physically duplicates an S3 object to a new key. Used when copying attachments
+ * between features/tickets/etc. so the copy is fully independent: deleting the
+ * original file later must not affect the copy.
+ * IMPORTANT: does NOT swallow errors — callers need the real error (e.g. NoSuchKey)
+ * to distinguish an orphaned DB reference from a genuine copy failure.
+ */
+const copyFileInS3 = async (sourceKey, destKey) => {
+    const result = await Storage.copy({ key: sourceKey, level: "public" }, { key: destKey, level: "public" });
+    return result.key;
+};
 
 function getDistanceBetweenTwoPoints(startPoint, endPoint) {
     const dx = endPoint.x - startPoint.x;
@@ -6759,13 +7341,16 @@ class NavigationService {
     }
     async getAllowedSweepsIDsForUserInSpace(spaceID) {
         const missionsForSpace = this.userService.currentMissions.filter((mis) => mis.spaceID === spaceID);
+        console.log(missionsForSpace);
         let navIDs = [];
         if (this.userService.userHasAccessToAllZonesInSpace(spaceID)) {
+            console.log(1);
             return this.getSweepsIDsForSpace(spaceID);
         }
         await Promise.all(missionsForSpace.map(async (mission) => {
             navIDs = [...navIDs, ...mission.zone.sweepIDs];
         }));
+        console.log('final navids = ', navIDs);
         return navIDs;
     }
     async getForbiddenNavigationIDsForUserInSpace(spaceID) {
@@ -7933,7 +8518,8 @@ class TicketsService extends BaseObjectService {
                 // partitionKey: "",
             }, 'AWSKinesis');
         }
-        return this.API.__proto__.CreateTicket(input);
+        const { id, createdAt, updatedAt, __typename, children, domain, ownerMission, equipments, prestataire, space, pois, ...graphqlInput } = input;
+        return this.API.CreateTicket(input);
     }
     async updateTicket(input) {
         return this.API.__proto__.UpdateTicket(input);
@@ -8315,6 +8901,21 @@ class EquipmentService extends BaseObjectService {
             return [];
         });
     }
+    /**
+     * Creates a Note attached to an equipment from an S3 key that ALREADY exists
+     * (as opposed to uploadDoc/uploadImage, which upload a fresh browser File).
+     * Used when duplicating equipment attachments during a cross-visit copy: the
+     * S3 object itself has already been physically copied by the caller beforehand,
+     * so this only needs to record the Note pointing at that new key.
+     */
+    async createNoteWithExistingAttachment(equipmentID, attachmentKey, type, ownerMissionID) {
+        return this.API.__proto__.CreateNote({
+            attachment: attachmentKey,
+            type,
+            equipmentID,
+            ownerMissionID,
+        });
+    }
     async uploadImage(equipment, imageFile) {
         return uploadFileToS3(this.prefix.image, imageFile, equipment.id).then(async (url) => {
             if (url) {
@@ -12692,33 +13293,26 @@ class MatterportImportService {
             iframe.addEventListener('load', async () => {
                 try {
                     this.sdk = await showcaseWindow.MP_SDK.connect(iframe, this.sdkKey, '');
-                    // Subscribe to Floor data
                     this.sdk.Floor.data.subscribe({
                         onCollectionUpdated: function upd(collection) {
-                            // console.log("Floors", collection);
                             this.floors = collection;
                         }.bind(this),
                     });
-                    // Subscribe to current Floor
                     this.sdk.Floor.current.subscribe(function upd(currentFloor) {
                         this.currentFloor = currentFloor;
                     }.bind(this));
-                    // Subscribe to Sweep data
                     this.sdk.Sweep.data.subscribe({
                         onCollectionUpdated: function upd(collection) {
                             console.log('the entire up-to-date collection', collection);
                             this.sweeps = collection;
                         }.bind(this),
                     });
-                    // remove labels
                     await this.sdk.Settings.update('labels', false);
                     let timeoutExpired = false;
-                    // start timeout
                     setTimeout(() => (timeoutExpired = true), 7000);
                     await waitUntil(() => (this.sweeps !== undefined && this.floors !== undefined) ||
                         timeoutExpired === true);
                     if (timeoutExpired) {
-                        // we are likely in matterport error case (that we cannot catch!)
                         console.log('timeout intitialising Matterport');
                         return rej(new Error('error init Matterport'));
                     }
@@ -12738,7 +13332,6 @@ class MatterportImportService {
         }
         let appIsLoaded = false;
         this.sdk.App.state.subscribe(function (appState) {
-            // app state has changed
             console.log('The current phase: ', appState.phase);
             if (appState.phase === 'appphase.playing') {
                 console.log('The app is playing');
@@ -12747,7 +13340,6 @@ class MatterportImportService {
         });
         await waitUntil(() => appIsLoaded === true);
         if (reloading) {
-            // perform only 360 import since we are reloading
             await this.import360images(overrideExisting);
             return Promise.resolve(true);
         }
@@ -12759,10 +13351,8 @@ class MatterportImportService {
             return Promise.reject(new Error('missing data (no main Building Zone)'));
         }
         console.log('importing data from matterport');
-        // save sweeps data as json
         const json = JSON.stringify(Object.values(this.sweeps));
         await uploadJsonToS3(`visits/${this.modelID}/inventory/`, json, 'data.json');
-        // check layer of building type
         const layerBuilding = await this.getLayerByName('BUILDING');
         const createdDefaultZone = await this.createZone(node.metadata, layerBuilding.id, surface, mainZone.id, Object.keys(this.sweeps), node);
         if (!createdDefaultZone) {
@@ -12771,7 +13361,6 @@ class MatterportImportService {
         if (this.floors) {
             floorZones = await this.importFloorData(createdDefaultZone.id, node);
         }
-        // console.log(floorZones);
         await Promise.all(Object.keys(this.sweeps).map(async (key) => {
             const sweepInfo = this.sweeps[key];
             const navigationInput = {
@@ -12811,7 +13400,6 @@ class MatterportImportService {
         const newLocal = await this.zoneService.create(zoneInput);
         return newLocal;
     }
-    // --- Main import function (complete) ---
     async import360images(overrideExisting = true) {
         console.log('Importing 360 images');
         this.importingImages.next(true);
@@ -12829,10 +13417,8 @@ class MatterportImportService {
                 }
                 const sweep = scans[index];
                 console.log('Moving to sweep:', sweep);
-                // Prefer legacy .id first, then uuid, then sid as last resort
                 const moveId = sweep.id || sweep.uuid || sweep.sid;
                 try {
-                    // Move to sweep (use the best available id)
                     await this.sdk.Sweep.moveTo(moveId, {
                         rotation: { x: 0, y: 0 },
                         transition: this.sdk.Camera && this.sdk.Camera.TransitionType
@@ -12840,7 +13426,6 @@ class MatterportImportService {
                             : undefined,
                         transitionTime: 0,
                     });
-                    // Capture with automatic retry (ensures renderer readiness each attempt)
                     const img = await this.captureEquirectangularWithRetry({ width: 2048, height: 1024 }, { mattertags: false, sweeps: true }, {
                         maxAttempts: 3,
                         initialBackoffMs: 500,
@@ -12848,10 +13433,7 @@ class MatterportImportService {
                         sweepIdForReadyCheck: moveId,
                         waitForSweepTimeoutMs: 12000
                     });
-                    // Upload asynchronously (do not await to keep throughput)
-                    uploadBase64ImageWithRetry(img, 
-                    // prefer using uuid for storage name if available, else fallback to moveId
-                    sweep.uuid || moveId, `visits/${this.modelID}/sweeps/`, 'sweep', 5).then(() => {
+                    uploadBase64ImageWithRetry(img, sweep.uuid || moveId, `visits/${this.modelID}/sweeps/`, 'sweep', 5).then(() => {
                         this.sweepProcessedCount.next(index);
                         if (index === nmbScans - 1) {
                             console.log('Import 360 done');
@@ -12864,38 +13446,29 @@ class MatterportImportService {
                     });
                 }
                 catch (err) {
-                    // capture failed after retries — log and continue to next sweep
                     console.error(`Failed to capture sweep ${moveId} after retries:`, err);
                     this.sweepProcessedCount.next(index);
-                    // continue to next sweep (change to `throw err` if you want to abort on first failure)
                     continue;
                 }
             }
-            // If loop finishes without hitting the final resolve in upload promise:
             resolve(true);
             this.removeFrame();
         });
     }
-    // --- capture with retry and backoff ---
-    // options: renderer size; renderOptions: renderer flags; cfg: retry config
     async captureEquirectangularWithRetry(options, renderOptions, { maxAttempts = 3, initialBackoffMs = 500, perAttemptTimeoutMs = 8000, sweepIdForReadyCheck = null, waitForSweepTimeoutMs = 12000 } = {}) {
         let attempt = 0;
         let lastError = null;
         while (attempt < maxAttempts) {
             attempt += 1;
             try {
-                // Ensure sweep is ready before each attempt if requested
                 if (sweepIdForReadyCheck) {
                     await this.waitForSweepReady(sweepIdForReadyCheck, waitForSweepTimeoutMs);
-                    // small safety delay to let renderer finalize
                     await this.sleep(120);
                 }
-                // Race the takeEquirectangular call against a per-attempt timeout
                 const img = await Promise.race([
                     this.sdk.Renderer.takeEquirectangular(options, renderOptions),
                     this.timeoutPromise(perAttemptTimeoutMs, `takeEquirectangular timed out after ${perAttemptTimeoutMs}ms`)
                 ]);
-                // success
                 return img;
             }
             catch (err) {
@@ -12904,37 +13477,27 @@ class MatterportImportService {
                 if (attempt >= maxAttempts) {
                     throw lastError;
                 }
-                // exponential backoff before next attempt
                 const backoff = initialBackoffMs * Math.pow(2, attempt - 1);
-                // add small jitter to reduce thundering herd
                 const jitter = Math.floor(Math.random() * 100);
                 await this.sleep(backoff + jitter);
-                // loop to next attempt
             }
         }
         throw lastError || new Error('captureEquirectangularWithRetry failed without error');
     }
-    // --- Wait until the SDK reports the target sweep as current ---
-    // Tries: sdk.Sweep.current.waitUntil -> sdk.Sweep.current.subscribe -> polling getCurrent/value
-    // This function matches targetId against multiple fields and prioritizes .id matching.
     waitForSweepReady(targetId, timeoutMs = 10000) {
         const sdk = this.sdk;
-        // helper to match multiple id fields, prioritizing id first
         const matchesTarget = (data) => {
             if (!data)
                 return false;
-            // check .id first (legacy), then uuid, sid, uid
             const fields = [data.id, data.uuid, data.sid, data.uid];
             return fields.some(f => !!f && String(f) === String(targetId));
         };
-        // 1) prefer waitUntil if available on the observable
         if (sdk.Sweep && sdk.Sweep.current && typeof sdk.Sweep.current.waitUntil === 'function') {
             return Promise.race([
                 sdk.Sweep.current.waitUntil((data) => matchesTarget(data)),
                 this.timeoutPromise(timeoutMs, `Timeout waiting for sweep ${targetId}`)
             ]);
         }
-        // 2) subscribe if available
         if (sdk.Sweep && sdk.Sweep.current && typeof sdk.Sweep.current.subscribe === 'function') {
             return new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {
@@ -12944,7 +13507,6 @@ class MatterportImportService {
                 }, timeoutMs);
                 let off = null;
                 try {
-                    // subscribe may return an unsubscribe function or an object with unsubscribe()
                     const subResult = sdk.Sweep.current.subscribe((data) => {
                         if (matchesTarget(data)) {
                             clearTimeout(timer);
@@ -12958,7 +13520,6 @@ class MatterportImportService {
                             resolve();
                         }
                     });
-                    // if subscribe returned an unsubscribe function, keep it as off
                     if (typeof subResult === 'function')
                         off = subResult;
                     else if (subResult && typeof subResult.unsubscribe === 'function')
@@ -12970,7 +13531,6 @@ class MatterportImportService {
                 }
             });
         }
-        // 3) polling fallback: try getCurrent(), sdk.Sweep.current() function, or .value, else poll renderer readiness
         return new Promise(async (resolve, reject) => {
             const pollInterval = 200;
             const timer = setTimeout(() => {
@@ -12984,11 +13544,9 @@ class MatterportImportService {
                         current = await sdk.Sweep.getCurrent();
                     }
                     else if (sdk.Sweep && typeof sdk.Sweep.current === 'function') {
-                        // some builds expose a function
                         current = await sdk.Sweep.current();
                     }
                     else if (sdk.Sweep && sdk.Sweep.current && sdk.Sweep.current.value) {
-                        // some observables expose a .value
                         current = sdk.Sweep.current.value;
                     }
                     if (matchesTarget(current)) {
@@ -13001,12 +13559,10 @@ class MatterportImportService {
                     // ignore and retry until timeout
                 }
             };
-            // initial immediate check
             await checkNow();
             const interval = setInterval(checkNow, pollInterval);
         });
     }
-    // --- small helpers ---
     sleep(ms) {
         return new Promise(res => setTimeout(res, ms));
     }
@@ -13027,7 +13583,6 @@ class MatterportImportService {
             console.log('Floor are not loaded yet');
             return;
         }
-        // look up for sequence number (the safest method)
         let floorMatterport = Object.values(this.floors).find((floor) => floor.sequence === matterportFloorSequence);
         if (!floorMatterport) {
             floorMatterport = Object.values(this.floors).find((floor) => floorName.includes(floor.name) && floor.name != '');
@@ -13035,13 +13590,11 @@ class MatterportImportService {
         if (!floorMatterport) {
             floorMatterport = Object.values(this.floors).find((floor) => floorName.includes(floor.id));
         }
-        // console.log(floorMatterport)
         if (floorMatterport) {
             let retry = true;
             while (retry) {
                 try {
                     const floorIndex = await this.sdk.Floor.moveTo(floorMatterport.sequence);
-                    // console.log("moved to floorIndex", floorIndex);
                     retry = false;
                 }
                 catch (error) {
@@ -13060,13 +13613,10 @@ class MatterportImportService {
         const nmbFloors = Object.keys(this.floors).length;
         console.log('Total number of floors', nmbFloors);
         for (let index = 0; index < nmbFloors; index += 1) {
-            // eslint-disable-next-line no-await-in-loop
             console.log('Importing floor', index);
             await this.sdk.Floor.moveTo(index).then(async () => {
                 await wait(700);
-                // console.log("about to save the floor", index);
                 const zone = await this.saveFloor(defautZoneID, node);
-                // console.log("received floor zone", zone);
                 zones.push(zone);
             });
         }
@@ -13084,14 +13634,12 @@ class MatterportImportService {
         console.log('sweeps for floor', sweepsForFloor.length);
         const sweepIDs = sweepsForFloor.map((sweep) => sweep.uuid);
         const zone = await this.createZone(`Étage ${name} - ${node.metadata}`, layerFloor.id, null, defautZoneID, sweepIDs, node, JSON.stringify({ matterportFloorSequence: this.currentFloor.sequence }));
-        // TODO link to scans
         const base64 = await this.sdk.Renderer.takeScreenShot({
             width: 4096,
             height: 2048,
         });
         const spaceIDshort = this.spaceID.slice(0, 8);
         await uploadBase64Image(base64, null, `visits/${this.modelID}/plans/`, `plan_floor_${this.currentFloor.id}_${spaceIDshort}`);
-        // create Plan object
         const plan = {
             name: `plan_floor_${this.currentFloor.id}`,
             annexe: `visits/${this.modelID}/plans/plan_floor_${this.currentFloor.id}_${spaceIDshort}.jpeg`,
@@ -13102,7 +13650,6 @@ class MatterportImportService {
             isImportedMatterport: true,
         };
         await this.planService.createPlan(plan);
-        // console.log("floor saved");
         return Promise.resolve(zone);
     }
     abandon() {
@@ -13124,7 +13671,6 @@ class MatterportImportService {
         if (layers.length > 0) {
             return layers[0];
         }
-        // create then
         return this.layerService.createLayerForOrganisation(name, currentOrgId);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportImportService, deps: [{ token: MATTERPORT_SDK_KEY }, { token: NavigationService }, { token: ZoneService }, { token: ViewerService }, { token: LayerService }, { token: BaseUserService }, { token: PlanService }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -13140,6 +13686,45 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: [MATTERPORT_SDK_KEY]
                 }] }, { type: NavigationService }, { type: ZoneService }, { type: ViewerService }, { type: LayerService }, { type: BaseUserService }, { type: PlanService }] });
 
+// matterport-transform.util.ts
+/**
+ * Computes the rigid transform (Y-axis rotation + translation) between two
+ * coordinate frames, from 2 pairs of points representing the same physical spot.
+ */
+function computeRigidTransform(sourceA, targetA, sourceB, targetB) {
+    const vSource = { x: sourceB.x - sourceA.x, z: sourceB.z - sourceA.z };
+    const vTarget = { x: targetB.x - targetA.x, z: targetB.z - targetA.z };
+    const angleSource = Math.atan2(vSource.z, vSource.x);
+    const angleTarget = Math.atan2(vTarget.z, vTarget.x);
+    return {
+        rotationYRad: angleTarget - angleSource,
+        refSource: sourceA,
+        refTarget: targetA
+    };
+}
+/** Applies the rigid transform to a 3D position (x, y, z). */
+function applyRigidTransformToPoint(p, t) {
+    const dx = p.x - t.refSource.x;
+    const dz = p.z - t.refSource.z;
+    const cos = Math.cos(t.rotationYRad);
+    const sin = Math.sin(t.rotationYRad);
+    return {
+        x: t.refTarget.x + (dx * cos - dz * sin),
+        y: t.refTarget.y + (p.y - t.refSource.y), // vertical axis is not rotated
+        z: t.refTarget.z + (dx * sin + dz * cos)
+    };
+}
+/** Applies the Y rotation (in degrees) to an orientation angle (a pose's yRotation). */
+function applyRigidTransformToYRotationDeg(yRotationDeg, t) {
+    const deltaDeg = t.rotationYRad * (180 / Math.PI);
+    return yRotationDeg + deltaDeg;
+}
+/** Euclidean distance between two points, useful to validate landmark quality. */
+function distance(a, b) {
+    const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+
 /* eslint-disable class-methods-use-this */
 class Object3DService {
     userService;
@@ -13506,6 +14091,855 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: ['currentAPIService']
                 }] }, { type: BaseUserService }, { type: NavigatorService }, { type: ZoneChangeService }, { type: FilterService }] });
 
+/** Safely extracts a readable message from an unknown catch value, including Amplify's
+ *  GraphQL error shape ({ data, errors: [{ errorType, message }] }). */
+function toErrorMessage(err) {
+    if (err && typeof err === 'object') {
+        const anyErr = err;
+        if (Array.isArray(anyErr.errors) && anyErr.errors.length > 0) {
+            return anyErr.errors
+                .map((e) => {
+                const title = e.errorType ? `${e.errorType}: ` : '';
+                return `${title}${e.message || 'Unknown error'}`;
+            })
+                .join(' | ');
+        }
+        if (err instanceof Error) {
+            return err.message;
+        }
+    }
+    if (typeof err === 'string') {
+        return err;
+    }
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+/** Thrown when the referenced S3 source file doesn't exist (orphaned DB reference —
+ *  e.g. the file was deleted or renamed on S3 without updating the database).
+ *  Kept distinct from other copy failures so the calling loop can log a clear,
+ *  specific message and skip the whole item instead of a generic error. */
+class MissingS3FileError extends Error {
+    sourceKey;
+    contextLabel;
+    constructor(sourceKey, contextLabel) {
+        super(`Source file missing on S3: "${sourceKey}" (${contextLabel})`);
+        this.sourceKey = sourceKey;
+        this.contextLabel = contextLabel;
+        this.name = 'MissingS3FileError';
+    }
+}
+class MatterportTagCopyService {
+    navigationService;
+    userService;
+    poiService;
+    ticketService;
+    equipmentService;
+    object3DService;
+    featureService;
+    measurementService;
+    commentService;
+    translate;
+    // Emits progress updates during copyTagsFromVisit(); null when idle
+    copyProgress$ = new BehaviorSubject(null);
+    // Emits the accumulated log lines during copyTagsFromVisit(); [] when idle
+    copyLog$ = new BehaviorSubject([]);
+    spModule;
+    log = [];
+    errorSeq = 0;
+    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, translate) {
+        this.navigationService = navigationService;
+        this.userService = userService;
+        this.poiService = poiService;
+        this.ticketService = ticketService;
+        this.equipmentService = equipmentService;
+        this.object3DService = object3DService;
+        this.featureService = featureService;
+        this.measurementService = measurementService;
+        this.commentService = commentService;
+        this.translate = translate;
+        this.spModule = userService.getSpModule();
+    }
+    //
+    // ---------- Public API ----------
+    //
+    async copyTagsFromVisit(sourceSpaceId, targetSpaceId, landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB) {
+        let errorCount = 0;
+        this.resetLog();
+        try {
+            console.log(`Copying Tags from source ${sourceSpaceId} to target ${targetSpaceId}`);
+            this.setStepProgress('collecting', 'collecting', 0);
+            this.copyProgress$.next({
+                phase: 'collecting',
+                processedInPhase: 0, totalInPhase: 0,
+                processedOverall: 0, totalOverall: 0,
+                percent: 0, errorCount: 0
+            });
+            const targetMission = this.userService.currentMission(targetSpaceId);
+            const targetMissionId = targetMission ? targetMission.id : null;
+            const transform = computeRigidTransform(landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB);
+            console.log('Rigid transform computed:', {
+                rotationYDeg: transform.rotationYRad * (180 / Math.PI),
+                refSource: transform.refSource,
+                refTarget: transform.refTarget
+            });
+            const sourceSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(sourceSpaceId);
+            const targetSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(targetSpaceId);
+            this.setStepProgress('collecting', 'collecting', 30);
+            const [sourceNavPositions, targetNavPositions] = await Promise.all([
+                this.buildNavigationPositionMap(sourceSpaceId, sourceSweepIds),
+                this.buildNavigationPositionMap(targetSpaceId, targetSweepIds)
+            ]);
+            const elementIds = {};
+            let sourceTickets = [];
+            let sourceEquipments = [];
+            let targetTickets = [];
+            let targetEquipments = [];
+            let sourceMeasurements = [];
+            let targetMeasurements = [];
+            if (this.spModule == SpModule.IMMO) {
+                sourceTickets = await this.ticketService.getTicketsBySpace(sourceSpaceId);
+                sourceEquipments = await this.equipmentService.getEquipmentsForSpace(sourceSpaceId);
+                targetTickets = await this.ticketService.getTicketsBySpace(targetSpaceId);
+                targetEquipments = await this.equipmentService.getEquipmentsForSpace(targetSpaceId);
+            }
+            this.setStepProgress('collecting', 'collecting', 55);
+            const sourceObjects3D = await this.object3DService.getObjects3DBySpace(sourceSpaceId);
+            const targetObjects3D = await this.object3DService.getObjects3DBySpace(targetSpaceId);
+            const sourceFeatures = await this.featureService.getFeaturesBySpaceWithoutFiltering(sourceSpaceId);
+            const targetFeatures = await this.featureService.getFeaturesBySpaceWithoutFiltering(targetSpaceId);
+            this.setStepProgress('collecting', 'collecting', 75);
+            if (this.spModule == SpModule.IMMO) {
+                sourceMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId);
+                targetMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId);
+            }
+            this.setStepProgress('collecting', 'collecting', 90);
+            const sourcePoisAll = await this.poiService.getPoisByMatterportSweeps(sourceSweepIds);
+            const targetPoisAll = await this.poiService.getPoisByMatterportSweeps(targetSweepIds);
+            const handledPoiTypes = new Set([
+                PoiType.TICKET, PoiType.EQUIPMENT, PoiType.DATA, PoiType.DESK,
+                PoiType.OBJECT3D, PoiType.MEASURE
+            ]);
+            const sourcePois = sourcePoisAll.filter(p => !handledPoiTypes.has(p.type));
+            const targetPois = targetPoisAll.filter(p => !handledPoiTypes.has(p.type));
+            this.setStepProgress('collecting', 'collecting', 100);
+            const totalOverall = sourceTickets.length + sourceEquipments.length + sourcePois.length
+                + sourceObjects3D.length + sourceFeatures.length + sourceMeasurements.length;
+            let processedOverall = 0;
+            const emitProgress = (phase, processedInPhase, totalInPhase) => {
+                this.copyProgress$.next({
+                    phase,
+                    processedInPhase,
+                    totalInPhase,
+                    processedOverall,
+                    totalOverall,
+                    percent: totalOverall > 0 ? Math.round((processedOverall / totalOverall) * 100) : 0,
+                    errorCount
+                });
+            };
+            if (this.spModule == SpModule.IMMO) {
+                // TICKETS
+                for (let i = 0; i < sourceTickets.length; i++) {
+                    const sourceObj = sourceTickets[i];
+                    try {
+                        const existsInTarget = this.matchesExisting(sourceObj, targetTickets);
+                        if (!existsInTarget) {
+                            const rawSource = sourceObj;
+                            const ticketInput = {
+                                title: rawSource.title,
+                                friendlyLabel: rawSource.friendlyLabel,
+                                status: rawSource.status,
+                                type: rawSource.type,
+                                priority: rawSource.priority,
+                                description: rawSource.description,
+                                level: rawSource.level,
+                                metadata: rawSource.metadata || null,
+                                read: rawSource.read || null,
+                                projectID: rawSource.projectID || null,
+                                problemCode: rawSource.problemCode || null,
+                                archivedForMissionID: rawSource.archivedForMissionID || null,
+                                spaceID: targetSpaceId,
+                                parentID: null,
+                                domainID: null,
+                                ownerMissionID: targetMissionId
+                            };
+                            const createdObj = await this.ticketService.createTicket(ticketInput);
+                            if (createdObj && createdObj.id) {
+                                elementIds[sourceObj.id] = createdObj.id;
+                            }
+                            if (sourceObj.pois.items && sourceObj.pois.items.length > 0) {
+                                const sourcePoi = sourceObj.pois.items[0];
+                                const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                                const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                                const poiInput = {
+                                    coordinate: JSON.stringify(adjustedCoordinate),
+                                    type: sourcePoi.type,
+                                    elementID: createdObj.id,
+                                    metadata: sourcePoi.metadata,
+                                    matterportSweepID: targetSweepId
+                                };
+                                await this.poiService.createPOIForSpaceID(poiInput);
+                            }
+                        }
+                    }
+                    catch (itemError) {
+                        console.error(`Error copying ticket "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
+                        errorCount++;
+                        this.logCopyItemError(itemError, 'errorTicket', sourceObj?.title || sourceObj?.id);
+                    }
+                    processedOverall++;
+                    emitProgress('tickets', i + 1, sourceTickets.length);
+                    const pct = sourceTickets.length > 0 ? Math.round(((i + 1) / sourceTickets.length) * 100) : 100;
+                    this.setStepProgress('tickets', 'tickets', pct);
+                }
+                // EQUIPMENTS (title, POI, PHOTO and NOTES/documents all copied — files physically
+                // duplicated in S3 first, so the copy stays independent from the source)
+                for (let i = 0; i < sourceEquipments.length; i++) {
+                    const sourceObj = sourceEquipments[i];
+                    try {
+                        const existsInTarget = this.matchesExisting(sourceObj, targetEquipments);
+                        if (!existsInTarget) {
+                            const rawSource = sourceObj;
+                            let copiedPhotoKey = null;
+                            if (rawSource.photo) {
+                                copiedPhotoKey = await this.copyS3KeyIfPresent(rawSource.photo, `equipment photo "${rawSource.title}"`);
+                            }
+                            const equipmentInput = {
+                                title: rawSource.title,
+                                status: rawSource.status,
+                                description: rawSource.description,
+                                archivedForMissionID: rawSource.archivedForMissionID || null,
+                                spaceID: targetSpaceId,
+                                domainID: null,
+                                photo: copiedPhotoKey,
+                            };
+                            const createdObj = await this.equipmentService.createEquipment(equipmentInput, null, null);
+                            if (createdObj && createdObj.id) {
+                                elementIds[sourceObj.id] = createdObj.id;
+                            }
+                            // Copy notes (documents, technical/financial/other/contractual/image notes)
+                            if (createdObj && rawSource.notes?.items && rawSource.notes.items.length > 0) {
+                                for (const sourceNote of rawSource.notes.items) {
+                                    try {
+                                        if (!sourceNote.attachment) {
+                                            continue; // nothing to duplicate for this note
+                                        }
+                                        const copiedKey = await this.copyS3KeyIfPresent(sourceNote.attachment, `equipment note for "${sourceObj?.title}"`);
+                                        await this.equipmentService.createNoteWithExistingAttachment(createdObj.id, copiedKey, sourceNote.type, targetMissionId);
+                                    }
+                                    catch (noteError) {
+                                        console.error(`Error copying note for equipment "${sourceObj?.title}":`, noteError);
+                                        errorCount++;
+                                        this.logCopyItemError(noteError, 'errorEquipmentNote', sourceObj?.title || sourceObj?.id);
+                                    }
+                                }
+                            }
+                            if (sourceObj.pois.items && sourceObj.pois.items.length > 0) {
+                                const sourcePoi = sourceObj.pois.items[0];
+                                const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                                const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                                const poiInput = {
+                                    coordinate: JSON.stringify(adjustedCoordinate),
+                                    type: sourcePoi.type,
+                                    elementID: createdObj.id,
+                                    metadata: sourcePoi.metadata,
+                                    matterportSweepID: targetSweepId
+                                };
+                                await this.poiService.createPOIForSpaceID(poiInput);
+                            }
+                        }
+                    }
+                    catch (itemError) {
+                        console.error(`Error copying equipment "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
+                        errorCount++;
+                        this.logCopyItemError(itemError, 'errorEquipment', sourceObj?.title || sourceObj?.id);
+                    }
+                    processedOverall++;
+                    emitProgress('equipments', i + 1, sourceEquipments.length);
+                    const pct = sourceEquipments.length > 0 ? Math.round(((i + 1) / sourceEquipments.length) * 100) : 100;
+                    this.setStepProgress('equipments', 'equipments', pct);
+                }
+                // Second pass: remap subequipmentsIDs on newly created equipments to point to
+                // their copied counterparts. IDs with no copied counterpart (source equipment
+                // wasn't copied — e.g. it already existed in target, or was skipped) are dropped
+                // rather than left dangling or pointing back at the source space's equipment.
+                for (const sourceObj of sourceEquipments) {
+                    const rawSource = sourceObj;
+                    const newId = elementIds[sourceObj.id];
+                    if (newId && rawSource.subequipmentsIDs && rawSource.subequipmentsIDs.length > 0) {
+                        const remapped = rawSource.subequipmentsIDs
+                            .map((subId) => elementIds[subId])
+                            .filter((id) => !!id);
+                        if (remapped.length > 0) {
+                            try {
+                                await this.equipmentService.updateEquipment({ id: newId, subequipmentsIDs: remapped });
+                            }
+                            catch (subEquipError) {
+                                console.error(`Error remapping sub-equipments for "${sourceObj?.title}":`, subEquipError);
+                                errorCount++;
+                                this.logCopyItemError(subEquipError, 'errorEquipmentSubEquip', sourceObj?.title || sourceObj?.id);
+                            }
+                        }
+                    }
+                }
+            }
+            // POIS (standalone — types already handled above are excluded)
+            for (let i = 0; i < sourcePois.length; i++) {
+                const sourcePoi = sourcePois[i];
+                try {
+                    const existsInTarget = targetPois.some(tp => tp.coordinate === sourcePoi.coordinate && tp.tagDescription === sourcePoi.tagDescription);
+                    if (!existsInTarget) {
+                        const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                        const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                        let elementID = sourcePoi.elementID;
+                        if (elementID && elementIds[elementID]) {
+                            elementID = elementIds[elementID];
+                        }
+                        const copiedTagIcon = await this.duplicateTagIcon(sourcePoi.tagIcon);
+                        const copiedTagImageID = await this.duplicateTagImageID(sourcePoi.tagImageID);
+                        const newPoi = {
+                            coordinate: JSON.stringify(adjustedCoordinate),
+                            type: sourcePoi.type,
+                            elementID: elementID,
+                            tagDescription: sourcePoi.tagDescription,
+                            tagIcon: copiedTagIcon,
+                            tagImageID: copiedTagImageID,
+                            virtual: sourcePoi.virtual,
+                            xRotation: sourcePoi.xRotation,
+                            yRotation: sourcePoi.yRotation,
+                            metadata: sourcePoi.metadata,
+                            matterportSweepID: targetSweepId
+                        };
+                        await this.poiService.createPOIForSpaceID(newPoi);
+                    }
+                }
+                catch (itemError) {
+                    console.error(`Error copying POI (sweep: ${sourcePoi?.matterportSweepID}):`, itemError);
+                    errorCount++;
+                    this.logCopyItemError(itemError, 'errorPoi', sourcePoi?.matterportSweepID);
+                }
+                processedOverall++;
+                emitProgress('pois', i + 1, sourcePois.length);
+                const pct = sourcePois.length > 0 ? Math.round(((i + 1) / sourcePois.length) * 100) : 100;
+                this.setStepProgress('pois', 'pois', pct);
+            }
+            // OBJECTS 3D (the 3D model file itself — `path` — is physically duplicated in S3)
+            for (let i = 0; i < sourceObjects3D.length; i++) {
+                const sourceObj = sourceObjects3D[i];
+                try {
+                    const existsInTarget = targetObjects3D.some(targetObj => targetObj.name === sourceObj.name);
+                    if (!existsInTarget) {
+                        const rawSource = sourceObj;
+                        let copiedPath = rawSource.path;
+                        if (rawSource.path) {
+                            copiedPath = await this.copyS3KeyIfPresent(rawSource.path, `3D object "${rawSource.name}"`);
+                        }
+                        /**
+                         * Strict parser to ensure [float, float, float] format for GraphQL.
+                         * Forces numbers, handles potential DynamoDB object structures,
+                         * and ensures we never send [0,0,0] for scale.
+                         */
+                        const toFloatArray = (val, defaultVal = [0, 0, 0]) => {
+                            let array = [];
+                            if (Array.isArray(val)) {
+                                // If DB format [ {N: "1"}, ... ]
+                                if (val.length > 0 && typeof val[0] === 'object' && 'N' in val[0]) {
+                                    array = val.map(item => parseFloat(item.N));
+                                }
+                                // If already standard array [1, 1, 1]
+                                else {
+                                    array = val.map(item => parseFloat(item));
+                                }
+                            }
+                            // If object {x, y, z}
+                            else if (val && typeof val === 'object') {
+                                array = [parseFloat(val.x), parseFloat(val.y), parseFloat(val.z)];
+                            }
+                            else {
+                                return defaultVal;
+                            }
+                            // Ensure we return valid numbers
+                            return array.map(n => isNaN(n) ? 0 : n);
+                        };
+                        const object3DInput = {
+                            path: copiedPath,
+                            name: rawSource.name,
+                            description: rawSource.description || "",
+                            viewFrustum: !!rawSource.viewFrustum,
+                            spaceID: targetSpaceId,
+                            position: toFloatArray(rawSource.position, [0, 0, 0]),
+                            rotation: toFloatArray(rawSource.rotation, [0, 0, 0]),
+                            // Enforce scale to be at least 1.0 if it's invalid
+                            scale: toFloatArray(rawSource.scale, [1, 1, 1])
+                        };
+                        // Debugging: Inspect the exact object sent to the mutation
+                        console.log(`[DEBUG] Sending Object3D "${rawSource.name}" to API:`, JSON.stringify(object3DInput));
+                        const createdObj = await this.object3DService.create(object3DInput);
+                        if (createdObj && createdObj.id) {
+                            elementIds[sourceObj.id] = createdObj.id;
+                        }
+                        if (sourceObj.pois?.items && sourceObj.pois.items.length > 0) {
+                            const sourcePoi = sourceObj.pois.items[0];
+                            const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                            const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                            const poiInput = {
+                                coordinate: JSON.stringify(adjustedCoordinate),
+                                type: sourcePoi.type,
+                                elementID: createdObj.id,
+                                metadata: sourcePoi.metadata,
+                                matterportSweepID: targetSweepId
+                            };
+                            await this.poiService.createPOIForSpaceID(poiInput);
+                        }
+                    }
+                }
+                catch (itemError) {
+                    console.error(`Error copying object3D "${sourceObj?.name}":`, itemError);
+                    errorCount++;
+                    this.logCopyItemError(itemError, 'errorObject3d', sourceObj?.name || sourceObj?.id);
+                }
+                processedOverall++;
+                emitProgress('objects3d', i + 1, sourceObjects3D.length);
+                const pct = sourceObjects3D.length > 0 ? Math.round(((i + 1) / sourceObjects3D.length) * 100) : 100;
+                this.setStepProgress('objects3d', 'objects3d', pct);
+            }
+            // FEATURES (title, POI, and attached comments — images/videos/docs/links — all copied,
+            // each file physically duplicated in S3 first)
+            for (let i = 0; i < sourceFeatures.length; i++) {
+                const sourceObj = sourceFeatures[i];
+                try {
+                    const existsInTarget = this.matchesExisting(sourceObj, targetFeatures);
+                    if (!existsInTarget) {
+                        const rawSource = sourceObj;
+                        const featureInput = {
+                            title: rawSource.title,
+                            shortDescription: rawSource.shortDescription,
+                            level: rawSource.level,
+                            type: rawSource.type,
+                            archivedForMissionID: rawSource.archivedForMissionID || null,
+                            stripeProductID: rawSource.stripeProductID || null,
+                            stripePriceID: rawSource.stripePriceID || null,
+                            bookingPriceMetadata: rawSource.bookingPriceMetadata || null,
+                            locale: rawSource.locale || null,
+                            hashtags: rawSource.hashtags || null,
+                            description: rawSource.description || null,
+                            domainID: null,
+                            spaceID: targetSpaceId,
+                            ownerMissionID: targetMissionId
+                        };
+                        const createdObj = await this.featureService.createFeature(featureInput);
+                        if (createdObj && createdObj.id) {
+                            elementIds[sourceObj.id] = createdObj.id;
+                        }
+                        if (createdObj && sourceObj.comments?.items && sourceObj.comments.items.length > 0) {
+                            for (const sourceComment of sourceObj.comments.items) {
+                                try {
+                                    const rawComment = sourceComment;
+                                    let copiedAnnexe = null;
+                                    if (rawComment.annexe) {
+                                        copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `feature attachment "${rawComment.title}"`);
+                                    }
+                                    const commentInput = {
+                                        title: rawComment.title,
+                                        type: rawComment.type,
+                                        annexe: copiedAnnexe,
+                                        externalLink: rawComment.externalLink || null,
+                                        dimensions: rawComment.dimensions || null,
+                                        index: rawComment.index,
+                                        shownInTag: rawComment.shownInTag,
+                                        isCoverImage: rawComment.isCoverImage,
+                                        featureID: createdObj.id,
+                                        spaceID: targetSpaceId,
+                                        ownerID: targetMissionId
+                                    };
+                                    await this.commentService.createComment(commentInput);
+                                }
+                                catch (attachmentError) {
+                                    console.error(`Error copying attachment "${sourceComment?.title}" for feature "${sourceObj?.title}":`, attachmentError);
+                                    errorCount++;
+                                    this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || sourceComment?.id);
+                                }
+                            }
+                        }
+                        if (sourceObj.pois?.items && sourceObj.pois.items.length > 0) {
+                            const sourcePoi = sourceObj.pois.items[0];
+                            const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                            const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                            const poiInput = {
+                                coordinate: JSON.stringify(adjustedCoordinate),
+                                type: sourcePoi.type,
+                                elementID: createdObj.id,
+                                metadata: sourcePoi.metadata,
+                                matterportSweepID: targetSweepId
+                            };
+                            await this.poiService.createPOIForSpaceID(poiInput);
+                        }
+                    }
+                }
+                catch (itemError) {
+                    console.error(`Error copying feature "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
+                    errorCount++;
+                    this.logCopyItemError(itemError, 'errorFeature', sourceObj?.title || sourceObj?.id);
+                }
+                processedOverall++;
+                emitProgress('features', i + 1, sourceFeatures.length);
+                const pct = sourceFeatures.length > 0 ? Math.round(((i + 1) / sourceFeatures.length) * 100) : 100;
+                this.setStepProgress('features', 'features', pct);
+            }
+            // MEASUREMENTS (IMMO only — a Comment + a positional-only POI, no rotation;
+            // the screenshot file is physically duplicated in S3 first)
+            if (this.spModule == SpModule.IMMO) {
+                for (let i = 0; i < sourceMeasurements.length; i++) {
+                    const sourceMeasurement = sourceMeasurements[i];
+                    try {
+                        const existsInTarget = targetMeasurements.some(tm => tm.comment.title === sourceMeasurement.comment.title);
+                        if (!existsInTarget) {
+                            const rawComment = sourceMeasurement.comment;
+                            let copiedAnnexe = null;
+                            if (rawComment.annexe) {
+                                copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `measurement screenshot "${rawComment.title}"`);
+                            }
+                            const commentInput = {
+                                title: rawComment.title,
+                                type: CommentType.MEASURE,
+                                dimensions: rawComment.dimensions || null,
+                                annexe: copiedAnnexe,
+                                spaceID: targetSpaceId,
+                            };
+                            const createdComment = await this.commentService.createComment(commentInput);
+                            if (createdComment && sourceMeasurement.poi) {
+                                const targetSweepId = this.findClosestTargetSweepId(sourceMeasurement.poi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                                const adjustedPosition = this.getAdjustedPositionOnly(sourceMeasurement.poi.coordinate, transform);
+                                const poiInput = {
+                                    coordinate: JSON.stringify(adjustedPosition),
+                                    type: PoiType.MEASURE,
+                                    elementID: createdComment.id,
+                                    metadata: sourceMeasurement.poi.metadata,
+                                    matterportSweepID: targetSweepId
+                                };
+                                await this.poiService.createPOIForSpaceID(poiInput);
+                            }
+                        }
+                    }
+                    catch (itemError) {
+                        console.error(`Error copying measurement "${sourceMeasurement?.comment?.title}":`, itemError);
+                        errorCount++;
+                        this.logCopyItemError(itemError, 'errorMeasurement', sourceMeasurement?.comment?.title || sourceMeasurement?.id);
+                    }
+                    processedOverall++;
+                    emitProgress('measurements', i + 1, sourceMeasurements.length);
+                    const pct = sourceMeasurements.length > 0 ? Math.round(((i + 1) / sourceMeasurements.length) * 100) : 100;
+                    this.setStepProgress('measurements', 'measurements', pct);
+                }
+            }
+            this.copyProgress$.next({
+                phase: 'done',
+                processedInPhase: 0, totalInPhase: 0,
+                processedOverall, totalOverall,
+                percent: 100, errorCount
+            });
+            this.setStepLog('done', errorCount > 0
+                ? this.translate.instant('matterportCopy.doneWithErrors', { count: errorCount })
+                : this.translate.instant('matterportCopy.done'));
+            return true;
+        }
+        catch (error) {
+            console.error('Error copying POIs:', error);
+            this.appendErrorLog(this.translate.instant('matterportCopy.errorGeneral', { error: toErrorMessage(error) }));
+            this.copyProgress$.next(null);
+            return false;
+        }
+    }
+    //
+    // ---------- Progress / log helpers ----------
+    //
+    /** Adds or updates a step line (identified by stepId) with new text, then republishes the log. */
+    setStepLog(stepId, text) {
+        const existingIndex = this.log.findIndex(e => e.type === 'step' && e.id === stepId);
+        const entry = { id: stepId, type: 'step', text };
+        if (existingIndex >= 0) {
+            this.log[existingIndex] = entry;
+        }
+        else {
+            this.log.push(entry);
+        }
+        this.copyLog$.next([...this.log]);
+    }
+    /** Appends a new, permanent log line (never overwritten), then republishes the log. */
+    appendErrorLog(text) {
+        this.errorSeq++;
+        this.log.push({ id: `error-${this.errorSeq}`, type: 'error', text });
+        this.copyLog$.next([...this.log]);
+    }
+    /** Resets the log for a new run. */
+    resetLog() {
+        this.log = [];
+        this.errorSeq = 0;
+        this.copyLog$.next([]);
+    }
+    /** Builds and sets a step's log line as "<translated label>: <percent>%", no step numbering. */
+    setStepProgress(stepId, translationKey, percent) {
+        const label = this.translate.instant(`matterportCopy.${translationKey}`);
+        this.setStepLog(stepId, `${label}: ${percent}%`);
+    }
+    /** Logs a translated, parameterized error line for a single failed item. */
+    logItemError(translationKey, params) {
+        const text = this.translate.instant(`matterportCopy.${translationKey}`, params);
+        this.appendErrorLog(text);
+    }
+    /** Logs an item-level error, using a specific "missing file / orphaned reference"
+     *  translation key when the cause is a MissingS3FileError, and the generic per-type
+     *  key otherwise. Keeps the copy log readable: a missing file is not a bug to
+     *  investigate the same way a network/permission error is. */
+    logCopyItemError(error, genericKey, itemLabel) {
+        if (error instanceof MissingS3FileError) {
+            this.logItemError('errorMissingS3FileSkipped', {
+                name: itemLabel,
+                file: error.sourceKey
+            });
+        }
+        else {
+            this.logItemError(genericKey, { name: itemLabel, error: toErrorMessage(error) });
+        }
+    }
+    //
+    // ---------- Duplicate detection ----------
+    //
+    /**
+     * Heuristic duplicate-detection: compares title AND description together instead of
+     * title alone, to reduce false positives when several source items happen to share
+     * the same title. Not a perfect guarantee, but meaningfully more robust.
+     */
+    matchesExisting(source, targetList) {
+        return targetList.some(t => t.title === source.title && (t.description || null) === (source.description || null));
+    }
+    //
+    // ---------- Sweep positions / rigid transform ----------
+    //
+    /**
+     * Fetches the position of every sweep in a space and returns it as a Map for O(1) lookup.
+     * Uses allSettled so a single failing sweep lookup doesn't abort the whole map —
+     * that sweep is simply absent from the resulting map (and skipped later).
+     */
+    async buildNavigationPositionMap(spaceId, sweepIds) {
+        const map = new Map();
+        const results = await Promise.allSettled(sweepIds.map(async (sid) => {
+            const navs = await this.navigationService.getNavigationsForMatterportIDForSpace(sid, spaceId);
+            if (navs && navs.length > 0 && navs[0].position) {
+                return { sid, position: JSON.parse(navs[0].position) };
+            }
+            return null;
+        }));
+        for (const result of results) {
+            if (result.status === 'fulfilled' && result.value) {
+                map.set(result.value.sid, result.value.position);
+            }
+            else if (result.status === 'rejected') {
+                console.warn('Failed to fetch a sweep position, skipping it:', result.reason);
+            }
+        }
+        return map;
+    }
+    /** Applies the rigid transform to a POI coordinate (position + orientation). */
+    getAdjustedCoordinates(coordinate, transform) {
+        if (coordinate === "null") {
+            return null;
+        }
+        if (!coordinate || typeof coordinate !== 'string') {
+            return coordinate;
+        }
+        const parsed = JSON.parse(coordinate);
+        const rotatedPos = applyRigidTransformToPoint({ x: parsed.x, y: parsed.y, z: parsed.z }, transform);
+        return {
+            x: rotatedPos.x,
+            y: rotatedPos.y,
+            z: rotatedPos.z,
+            xRotation: parsed.xRotation,
+            yRotation: applyRigidTransformToYRotationDeg(parsed.yRotation, transform)
+        };
+    }
+    /**
+     * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,
+     * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored
+     * coordinate is a bare position (no orientation), unlike other POI types.
+     */
+    getAdjustedPositionOnly(coordinate, transform) {
+        if (!coordinate || typeof coordinate !== 'string' || coordinate === 'null') {
+            return coordinate;
+        }
+        const parsed = JSON.parse(coordinate);
+        return applyRigidTransformToPoint({ x: parsed.x, y: parsed.y, z: parsed.z }, transform);
+    }
+    /**
+     * Finds the closest target sweep, comparing positions in the SAME coordinate frame.
+     * Pure in-memory lookup — no network call, thanks to the pre-built position maps.
+     */
+    findClosestTargetSweepId(sourceSweepID, sourceNavPositions, targetNavPositions, transform) {
+        if (!sourceSweepID)
+            return null;
+        const sourcePos = sourceNavPositions.get(sourceSweepID);
+        if (!sourcePos)
+            return null;
+        const sourcePosInTargetFrame = applyRigidTransformToPoint(sourcePos, transform);
+        let closestSweepID = null;
+        let minDistance = Infinity;
+        for (const [targetSweepId, targetPos] of targetNavPositions.entries()) {
+            const dx = targetPos.x - sourcePosInTargetFrame.x;
+            const dy = targetPos.y - sourcePosInTargetFrame.y;
+            const dz = targetPos.z - sourcePosInTargetFrame.z;
+            const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            if (dist < minDistance) {
+                minDistance = dist;
+                closestSweepID = targetSweepId;
+            }
+        }
+        return closestSweepID;
+    }
+    //
+    // ---------- S3 file duplication ----------
+    //
+    /** Generates a short random id, used to give each copied S3 file a fresh, collision-safe key. */
+    generateShortId() {
+        return Math.random().toString(36).slice(2, 10);
+    }
+    /**
+     * Builds a new S3 key for a copied attachment and sanitizes the filename
+     * to prevent AWS Amplify SignatureDoesNotMatch errors.
+     */
+    buildCopiedAttachmentKey(sourceAnnexe) {
+        const lastSlash = sourceAnnexe.lastIndexOf('/');
+        const folder = sourceAnnexe.substring(0, lastSlash + 1);
+        let filename = sourceAnnexe.substring(lastSlash + 1);
+        // Strip a leading "<8 hex chars>_" id prefix if present
+        const prefixMatch = filename.match(/^[0-9a-fA-F-]{8}_(.+)$/);
+        if (prefixMatch) {
+            filename = prefixMatch[1];
+        }
+        // SANITIZATION: Replace spaces, parentheses, and accents with underscores
+        // Crucial to prevent Amplify's Storage.copy from failing the signature calculation
+        filename = filename.replace(/[^a-zA-Z0-9.\-_]/g, '_');
+        const newPrefix = `${this.generateShortId()}_`;
+        return `${folder}${newPrefix}${filename}`;
+    }
+    /**
+     * Duplicates an S3 object if a key is present.
+     * - If the source file is genuinely missing from S3 (NoSuchKey / orphaned DB reference),
+     *   throws a MissingS3FileError so the caller can log a clear, specific message and
+     *   skip the whole item entirely, rather than creating a record with a broken file link.
+     * - Any other kind of failure (permissions, network, etc.) still throws a generic Error.
+     */
+    async copyS3KeyIfPresent(key, contextLabel) {
+        if (!key) {
+            return null;
+        }
+        const sourceKey = this.extractS3KeyFromValue(key);
+        const destKey = this.buildCopiedAttachmentKey(sourceKey);
+        // Log the source key to ensure it matches the real S3 object path
+        console.log(`[DEBUG] Attempting S3 copy from source: "${sourceKey}" to dest: "${destKey}"`);
+        try {
+            const copied = await copyFileInS3(sourceKey, destKey);
+            if (!copied) {
+                throw new MissingS3FileError(sourceKey, contextLabel);
+            }
+            return copied;
+        }
+        catch (error) {
+            const isMissingFile = error instanceof MissingS3FileError
+                || error?.code === 'NoSuchKey'
+                || /NoSuchKey|does not exist/i.test(toErrorMessage(error));
+            if (isMissingFile) {
+                console.warn(`[MatterportTagCopyService] Orphaned S3 reference, skipping item: "${sourceKey}" (${contextLabel})`);
+                throw new MissingS3FileError(sourceKey, contextLabel);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Duplicates the file referenced by a POI's tagIcon (a JSON string shaped like
+     * { src, opacity }, per form-feature.component.ts). If the JSON can't be parsed or
+     * has no `src`, the value is returned unchanged rather than risk corrupting it.
+     */
+    async duplicateTagIcon(tagIconRaw) {
+        if (!tagIconRaw) {
+            return tagIconRaw;
+        }
+        try {
+            const parsed = JSON.parse(tagIconRaw);
+            if (parsed && parsed.src) {
+                parsed.src = await this.copyS3KeyIfPresent(parsed.src, 'tag icon');
+            }
+            return JSON.stringify(parsed);
+        }
+        catch {
+            // Not JSON, or unexpected shape — leave untouched rather than guess.
+            return tagIconRaw;
+        }
+    }
+    /**
+     * Duplicates tagImageID if it looks like a reference to a file (contains a path
+     * separator, whether raw key or pre-signed URL). UNCONFIRMED ASSUMPTION: this
+     * field's exact semantics weren't verified — if it's actually an opaque reference
+     * to another DB record rather than a file, this heuristic may incorrectly attempt
+     * a copy. Confirm the real structure to tighten this if it causes issues.
+     */
+    async duplicateTagImageID(tagImageID) {
+        if (!tagImageID || !tagImageID.includes('/')) {
+            return tagImageID;
+        }
+        return this.copyS3KeyIfPresent(tagImageID, 'tag image');
+    }
+    /**
+     * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL
+     * or already a raw key).
+     * IMPORTANT: this must return the RAW (decoded, non URL-encoded) key. Amplify's
+     * Storage.copy() already builds and encodes the 'x-amz-copy-source' header internally
+     * from the key we give it. Pre-encoding it here caused a double-encoding bug (e.g. a
+     * space became "%2520" instead of "%20"), so Storage.copy() looked for a key that never
+     * existed on S3, resulting in a NoSuchKey error.
+     */
+    extractS3KeyFromValue(value) {
+        if (!value) {
+            return '';
+        }
+        let extracted = value;
+        // 1. Extract path from URL and drop query params
+        if (value.startsWith('http://') || value.startsWith('https://')) {
+            try {
+                const url = new URL(value);
+                extracted = decodeURIComponent(url.pathname);
+            }
+            catch {
+                extracted = value.split('?')[0];
+            }
+        }
+        else {
+            extracted = value.split('?')[0];
+        }
+        // 2. Remove leading slash
+        if (extracted.startsWith('/')) {
+            extracted = extracted.substring(1);
+        }
+        // 3. Remove 'public/' prefix
+        // Amplify prepends this automatically; we must strip it from the input
+        // to avoid the 'public/public/' double-prefix issue.
+        if (extracted.startsWith('public/')) {
+            extracted = extracted.substring('public/'.length);
+        }
+        // Return the raw key as-is — Storage.copy() takes care of properly encoding it
+        // for the CopySource header. Do NOT re-encode it here.
+        return extracted;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, deps: [{ token: NavigationService }, { token: BaseUserService }, { token: PoiService }, { token: TicketsService }, { token: EquipmentService }, { token: Object3DService }, { token: FeatureService }, { token: MeasurementService }, { token: CommentService }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: NavigationService }, { type: BaseUserService }, { type: PoiService }, { type: TicketsService }, { type: EquipmentService }, { type: Object3DService }, { type: FeatureService }, { type: MeasurementService }, { type: CommentService }, { type: i1.TranslateService }] });
+
 /* eslint-disable class-methods-use-this */
 class OrganisationService {
     smarterPlanID = "6e28201f-4679-4c29-9d2d-8a325f57cee9";
@@ -13713,5 +15147,5 @@ function floatValidator() {
  * Generated bundle index. Do not edit.
  */
 
-export { AffectationService, AvatarComponent, BaseLateralTabService, BaseTagService, BaseUserService, BaseVisibilityService, CameraMode, CaptureService, CaptureViewer, CommentService, CommentType, Config, ContentService, CsvExportComponent, DomainService, DomainType, DurationToStringPipe, EmailStatus, EquipmentService, EventService, EventStatus, EventType, FeatureService, FeatureType, FilterService, HashtagFromIdPipe, HashtagService, InterventionService, InventoryStatus, LayerService, LevelStatus, LoaderComponent, Locale, LocaleService, MATTERPORT_SDK_KEY, MatterportImportService, MatterportService, MattertagActionMode, MattertagData, MeasurementService, MenuBarComponent, MissionService, NavigationService, NavigatorService, NgxSmarterplanCoreModule, NgxSmarterplanCoreService, NodeService, Object3DService, OperationService, OrganisationService, PaymentStatus, PlanService, PoiService, PoiType, ProfileEntity, ProfileService, ProfileStatus, PropertyService, PropertyType, RoleStatus, SafeUrlPipe, SearchBarComponent, SearchObjectType, SearchService, SpModule, SpaceService, SpaceStatus, StatusEquipment, SupportModalComponent, SupportService, TagAction, TemplateService, TicketPriority, TicketStatus, TicketType, TicketsService, TimeDateToLocalStringPipe, TypeNote, UsernameFromIdPipe, ValidatorsService, ViewerInteractions, ViewerService, VisitService, ZoneChangeService, ZoneService, arraysContainSameElements, checkElementById, convertTimestampToLocalZone, dateHasExpired, dateTimeToLocalString, deleteFromS3, downloadBlob, downloadEquipmentDocument, downloadFile, downloadFileAsObject, durationToString, emailValidator, enumToArray, filterUniqueArrayByID, floatValidator, getBufferForFileFromS3, getCoefficientsForImage, getCurrentLang, getDistanceBetweenTwoPoints, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getLocaleLong, getLocaleShort, getMetaForImage, getRolesBelowForManager, getSignedFile, getSignedImageUrlForEquipment, getSignedImageUrlForProfile, getSignedImageUrlForSpace, getSpaceIDFromUrl, getVisitUrl, isEmptyObject, listFilesInFolder, mean, noEmptyValidator, numberToDateString, openDocument, openModalForVisitSwitch, poiTypeToString, pointToString, removeAllFilesFromFolderS3, removeNullKeysFromObject, showScanPointsOnPlanInDiv, shuffleArray, sortAlphabeticallyOnName, stringLocaleToEnum, stringToLowercaseNoSpaces, styleButton, textValidator, translateDatePeriod, uploadBase64Image, uploadBase64ImageWithRetry, uploadFileToS3, uploadJsonToS3, validEmail, wait, waitUntil };
+export { AffectationService, AvatarComponent, BaseLateralTabService, BaseTagService, BaseUserService, BaseVisibilityService, CameraMode, CaptureService, CaptureViewer, CommentService, CommentType, Config, ContentService, CsvExportComponent, DomainService, DomainType, DurationToStringPipe, EmailStatus, EquipmentService, EventService, EventStatus, EventType, FeatureService, FeatureType, FilterService, HashtagFromIdPipe, HashtagService, InterventionService, InventoryStatus, LayerService, LevelStatus, LoaderComponent, Locale, LocaleService, MATTERPORT_SDK_KEY, MatterportImportService, MatterportService, MatterportTagCopyService, MatterportViewType, MattertagActionMode, MattertagData, MeasurementService, MenuBarComponent, MissionService, NavigationService, NavigatorService, NgxSmarterplanCoreModule, NgxSmarterplanCoreService, NodeService, Object3DService, OperationService, OrganisationService, PaymentStatus, PlanService, PoiService, PoiType, ProfileEntity, ProfileService, ProfileStatus, PropertyService, PropertyType, RoleStatus, SafeUrlPipe, SearchBarComponent, SearchObjectType, SearchService, SpModule, SpaceService, SpaceStatus, StatusEquipment, SupportModalComponent, SupportService, TagAction, TemplateService, TicketPriority, TicketStatus, TicketType, TicketsService, TimeDateToLocalStringPipe, TypeNote, UsernameFromIdPipe, ValidatorsService, ViewerInteractions, ViewerService, VisitService, ZoneChangeService, ZoneService, applyRigidTransformToPoint, applyRigidTransformToYRotationDeg, arraysContainSameElements, checkElementById, computeRigidTransform, convertTimestampToLocalZone, copyFileInS3, dateHasExpired, dateTimeToLocalString, deleteFromS3, distance, downloadBlob, downloadEquipmentDocument, downloadFile, downloadFileAsObject, durationToString, emailValidator, enumToArray, filterUniqueArrayByID, floatValidator, getBufferForFileFromS3, getCoefficientsForImage, getCurrentLang, getDistanceBetweenTwoPoints, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getLocaleLong, getLocaleShort, getMetaForImage, getRolesBelowForManager, getSignedFile, getSignedImageUrlForEquipment, getSignedImageUrlForProfile, getSignedImageUrlForSpace, getSpaceIDFromUrl, getVisitUrl, isEmptyObject, listFilesInFolder, mean, noEmptyValidator, numberToDateString, openDocument, openModalForVisitSwitch, poiTypeToString, pointToString, removeAllFilesFromFolderS3, removeNullKeysFromObject, showScanPointsOnPlanInDiv, shuffleArray, sortAlphabeticallyOnName, stringLocaleToEnum, stringToLowercaseNoSpaces, styleButton, textValidator, translateDatePeriod, uploadBase64Image, uploadBase64ImageWithRetry, uploadFileToS3, uploadJsonToS3, validEmail, wait, waitUntil };
 //# sourceMappingURL=smarterplan-ngx-smarterplan-core.mjs.map