@smarterplan/ngx-smarterplan-core 1.4.12 → 1.4.14

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

@@ -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.
@@ -3407,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;
@@ -3417,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;
     }
@@ -3429,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) {
@@ -3436,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)
@@ -3450,36 +3573,40 @@ class MatterportTagService {
     async addMattertagToViewer(sdk, mattertagData) {
         if (!sdk)
             return null;
-        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('---------------');
-        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;
     }
@@ -3498,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);
@@ -3545,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)
@@ -3624,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
@@ -3637,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)
@@ -3669,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) { }
             }
@@ -3680,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;
@@ -3742,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) {
@@ -3809,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));
@@ -3831,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.
@@ -3843,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: {
@@ -3869,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' });
@@ -3987,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;
     }
@@ -4142,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] : []);
@@ -4240,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) {
@@ -4253,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);
@@ -4393,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,
@@ -4420,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;
@@ -4470,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())
@@ -4488,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());
@@ -4520,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. */
@@ -4545,12 +4700,9 @@ 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())
@@ -4634,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;
@@ -4660,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), 
@@ -4703,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
@@ -4768,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);
     }
@@ -4885,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: {
@@ -4901,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);
@@ -4912,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;
             }
         }
@@ -4955,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() {
@@ -5006,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;
@@ -5253,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')) {
@@ -5693,6 +6000,34 @@ const copyFileInS3 = async (sourceKey, destKey) => {
     const result = await Storage.copy({ key: sourceKey, level: "public" }, { key: destKey, level: "public" });
     return result.key;
 };
+/**
+ * Fallback duplication: downloads the object and re-uploads it under the new key.
+ *
+ * Storage.copy() builds the S3 `x-amz-copy-source` header by plain string concatenation
+ * (see @aws-amplify/storage AWSS3Provider.copy: `${bucket}/${srcPrefix}${srcKey}`), with no
+ * URL-encoding of the key. A key holding a space, an accent or a parenthesis therefore
+ * yields a header that does not match the signed canonical request, and S3 answers
+ * "The request signature we calculated does not match the signature you provided".
+ *
+ * Round-tripping the bytes avoids that header entirely and works for any key, at the cost
+ * of transferring the file through the browser — hence its use as a fallback only.
+ * IMPORTANT: like copyFileInS3, this must NOT swallow errors.
+ */
+const copyFileInS3ViaDownload = async (sourceKey, destKey) => {
+    const downloaded = await Storage.get(sourceKey, {
+        download: true,
+        level: "public",
+    });
+    const body = downloaded?.Body;
+    if (!body) {
+        throw new Error(`Empty download for "${sourceKey}", cannot duplicate it`);
+    }
+    const result = await Storage.put(destKey, body, {
+        level: "public",
+        contentType: downloaded.ContentType || undefined,
+    });
+    return result.key;
+};
 
 function getDistanceBetweenTwoPoints(startPoint, endPoint) {
     const dx = endPoint.x - startPoint.x;
@@ -8601,12 +8936,14 @@ class EquipmentService extends BaseObjectService {
      * 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) {
+    async createNoteWithExistingAttachment(equipmentID, attachmentKey, type, ownerMissionID, dates = {}) {
         return this.API.__proto__.CreateNote({
             attachment: attachmentKey,
             type,
             equipmentID,
             ownerMissionID,
+            signDate: dates.signDate ?? null,
+            expirationDate: dates.expirationDate ?? null,
         });
     }
     async uploadImage(equipment, imageFile) {
@@ -9320,6 +9657,33 @@ class HashtagService {
     async getHashtag(hashtagID) {
         return this.API.__proto__.GetHashtag(hashtagID);
     }
+    /*
+     * ---------------------------------------------------------------------------
+     * Pure data access — NO side effect on currentHashtags / currentSpaceID.
+     *
+     * `currentHashtags` is shared UI state read by HashtagFromIdPipe to render a
+     * keyword's name. Batch work (space duplication, export, admin tooling) touches
+     * hashtags of spaces the operator is not editing, and must not reshape what the
+     * screens are displaying — hence this side-effect-free trio.
+     * ---------------------------------------------------------------------------
+     */
+    /** Reads a space's keywords without touching the shared cache. */
+    async listHashtagsForSpace(spaceID) {
+        return this.API.__proto__.HashtagsBySpace(spaceID).then((response) => response.items);
+    }
+    /** Creates a keyword in a space without adding it to the shared cache. */
+    async createHashtagForSpace(name, spaceID) {
+        return this.API.__proto__.CreateHashtag({ name, spaceID });
+    }
+    /** Deletes a keyword without touching the shared cache. */
+    async deleteHashtagById(hashtagID) {
+        return this.API.__proto__.DeleteHashtag({ id: hashtagID });
+    }
+    /*
+     * ---------------------------------------------------------------------------
+     * UI-facing operations — same actions, plus maintenance of the shared cache.
+     * ---------------------------------------------------------------------------
+     */
     async createHashtag(hashtag) {
         const hashtagCreated = await this.API.__proto__.CreateHashtag(hashtag);
         this.currentHashtags.push(hashtagCreated);
@@ -9333,7 +9697,7 @@ class HashtagService {
             return this.currentHashtags;
         }
         this.currentSpaceID = spaceID;
-        return this.API.__proto__.HashtagsBySpace(spaceID).then((response) => response.items);
+        return this.listHashtagsForSpace(spaceID);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HashtagService, deps: [{ token: 'currentAPIService' }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HashtagService, providedIn: "root" });
@@ -9353,14 +9717,33 @@ class HashtagFromIdPipe {
     constructor(hashtagService) {
         this.hashtagService = hashtagService;
     }
+    /**
+     * Resolves a hashtag id to its display name.
+     *
+     * The cache is consulted for THIS id, and the network answers whenever the id is not
+     * in it.
+     *
+     * Hashtag ids are globally unique, so a cache holding entries from several spaces can
+     * only ever produce a correct hit or a miss, never a wrong name.
+     */
     async transform(hashtagID) {
-        if (this.hashtagService.currentHashtags.length === 0) {
-            return this.hashtagService.getHashtag(hashtagID).then((hashtag) => {
-                return hashtag.name;
-            });
+        if (!hashtagID) {
+            return "";
+        }
+        const cached = this.hashtagService.currentHashtags.find((_hashtag) => _hashtag.id === hashtagID);
+        if (cached) {
+            return cached.name ?? "";
+        }
+        try {
+            const hashtag = await this.hashtagService.getHashtag(hashtagID);
+            return hashtag?.name ?? "";
+        }
+        catch (error) {
+            // A keyword that cannot be read (deleted, network hiccup) must not break the
+            // rendering of the POI that carries it.
+            console.warn(`[HashtagFromIdPipe] Could not resolve the keyword "${hashtagID}":`, error);
+            return "";
         }
-        const hashtag = this.hashtagService.currentHashtags.find((_hashtag) => _hashtag.id === hashtagID);
-        return hashtag ? hashtag.name : "";
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HashtagFromIdPipe, deps: [{ token: HashtagService }], target: i0.ɵɵFactoryTarget.Pipe });
     static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: HashtagFromIdPipe, name: "hashtagFromID" });
@@ -10080,6 +10463,40 @@ class CommentService {
     async createComment(comment) {
         return this.API.__proto__.CreateComment(comment);
     }
+    /**
+     * Returns EVERY comment attached to a feature, following `nextToken` until the
+     * connection is exhausted.
+     *
+     * The `comments` connection nested inside FeaturesBySpace/GetFeature is capped by
+     * the AppSync resolver (`$util.defaultIfNull($context.args.limit, 100)`) and exposes
+     * a `nextToken` that nobody follows, so a media-rich POI silently loses every
+     * attachment past the first page. Anything that must see the complete media set of
+     * a feature (duplication, export, audit) has to use this method rather than
+     * `feature.comments.items`.
+     */
+    async getAllCommentsForFeature(featureID) {
+        return this.getAllCommentsPaginated((limit, nextToken) => this.API.__proto__.CommentsByFeature(featureID, undefined, undefined, limit, nextToken), featureID);
+    }
+    /** Same as getAllCommentsForFeature(), for the attachments of a ticket. */
+    async getAllCommentsForTicket(ticketID) {
+        return this.getAllCommentsPaginated((limit, nextToken) => this.API.__proto__.CommentsByTicket(ticketID, undefined, undefined, limit, nextToken), ticketID);
+    }
+    /** Drains a paginated comment query until its nextToken is exhausted. */
+    async getAllCommentsPaginated(fetchPage, ownerID) {
+        if (!ownerID) {
+            return [];
+        }
+        const all = [];
+        let nextToken = null;
+        do {
+            const page = await fetchPage(1000, nextToken);
+            if (page?.items?.length > 0) {
+                all.push(...page.items.filter((item) => !!item));
+            }
+            nextToken = page?.nextToken ?? null;
+        } while (nextToken);
+        return all;
+    }
     async updateComment(input) {
         return this.API.__proto__.UpdateComment(input);
     }
@@ -11361,6 +11778,31 @@ class FeatureService extends BaseObjectService {
         }
         return features;
     }
+    /**
+     * Returns EVERY feature of a space, following `nextToken` until the index is
+     * exhausted, with no user/archive filtering at all.
+     *
+     * `getFeaturesBySpaceWithoutFiltering()` reads a single page (the AppSync default
+     * caps it at 100 items) and calls `isArchived()`, which dereferences the current
+     * user's mission ON THAT SPACE — so it both truncates large spaces and throws for a
+     * space the operator has no mission on. Duplication has to see the raw, complete
+     * list, hence this separate accessor rather than a change of the existing one.
+     */
+    async getAllFeaturesBySpaceRaw(spaceID) {
+        if (!spaceID) {
+            return [];
+        }
+        const all = [];
+        let nextToken = null;
+        do {
+            const page = await this.API.__proto__.FeaturesBySpace(spaceID, undefined, undefined, 1000, nextToken);
+            if (page?.items?.length > 0) {
+                all.push(...page.items.filter((item) => !!item));
+            }
+            nextToken = page?.nextToken ?? null;
+        } while (nextToken);
+        return all;
+    }
     isBookingPlace(feature) {
         feature.isBookingPlace = feature.type === FeatureType.DESK;
     }
@@ -13407,16 +13849,42 @@ function applyRigidTransformToPoint(p, t) {
         z: t.refTarget.z + (dx * sin + dz * cos)
     };
 }
-/** Applies the Y rotation (in degrees) to an orientation angle (a pose's yRotation). */
+/**
+ * Applies the Y rotation (in degrees) to an orientation angle (a pose's yRotation).
+ * A null/undefined/non-numeric angle is returned untouched: "no orientation stored"
+ * must stay "no orientation stored", not become the raw rotation delta.
+ */
 function applyRigidTransformToYRotationDeg(yRotationDeg, t) {
+    if (yRotationDeg === null || yRotationDeg === undefined || Number.isNaN(Number(yRotationDeg))) {
+        return yRotationDeg;
+    }
     const deltaDeg = t.rotationYRad * (180 / Math.PI);
-    return yRotationDeg + deltaDeg;
+    return Number(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);
 }
+/**
+ * Applies ONLY the rotation part of the transform to a direction vector
+ * (a normal, a stem vector, ...).
+ *
+ * A direction has no origin, so the translation must NOT be applied to it —
+ * doing so would turn a unit normal into a point somewhere in the target model.
+ * Used for a POI's `metadata.normal`, which drives the orientation of the tag's
+ * stem: without this rotation, a pastille copied into a space whose model is
+ * rotated relative to the source ends up pointing into the wall it is stuck on.
+ */
+function applyRigidTransformToDirection(v, t) {
+    const cos = Math.cos(t.rotationYRad);
+    const sin = Math.sin(t.rotationYRad);
+    return {
+        x: v.x * cos - v.z * sin,
+        y: v.y, // vertical axis is not rotated
+        z: v.x * sin + v.z * cos
+    };
+}
 
 /* eslint-disable class-methods-use-this */
 class Object3DService {
@@ -13835,6 +14303,8 @@ class MatterportTagCopyService {
     featureService;
     measurementService;
     commentService;
+    hashtagService;
+    spaceService;
     translate;
     // Emits progress updates during copyTagsFromVisit(); null when idle
     copyProgress$ = new BehaviorSubject(null);
@@ -13843,7 +14313,34 @@ class MatterportTagCopyService {
     spModule;
     log = [];
     errorSeq = 0;
-    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, translate) {
+    // ---- Per-run remapping state (reset by resetRunState() at the start of every copy) ----
+    /** source element id -> id of its copy in the target space. */
+    elementIds = {};
+    /** source Comment id -> id of its copy. Needed to remap POI.tagImageID, which is a
+     *  reference to a Comment record (see the schema: "connection to comment.id"). */
+    commentIds = new Map();
+    // Hashtags are space-scoped records, so their ids can never be carried over as-is: they
+    // are matched by NAME against the target space, and the missing ones are created there.
+    // That creation is deliberately lazy — see resolveHashtagIds() — and audited, so an
+    // interrupted copy cannot leave keywords behind that no POI references.
+    /** source Hashtag id -> its name. */
+    sourceHashtagNames = new Map();
+    /** normalised hashtag name -> its id in the TARGET space (pre-existing or just created). */
+    targetHashtagIdsByName = new Map();
+    /** ids of the hashtags this run created in the target space. */
+    createdHashtagIds = new Set();
+    /** ids of the hashtags actually persisted on a successfully created feature. Anything in
+     *  createdHashtagIds but absent here is an orphan and is deleted at the end of the run. */
+    usedHashtagIds = new Set();
+    /** source ids of the elements whose POIs were already created by an element phase.
+     *  Guards the standalone POI phase against creating a second, impoverished copy. */
+    handledElementIds = new Set();
+    /** true when source and target spaces belong to the same organisation. Domains are
+     *  organisation-scoped (no spaceID), so domainID survives the copy only in that case. */
+    sameOrganisation = false;
+    /** Target space id of the run in progress — used to re-home copied tag icons. */
+    targetSpaceId = null;
+    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, hashtagService, spaceService, translate) {
         this.navigationService = navigationService;
         this.userService = userService;
         this.poiService = poiService;
@@ -13853,6 +14350,8 @@ class MatterportTagCopyService {
         this.featureService = featureService;
         this.measurementService = measurementService;
         this.commentService = commentService;
+        this.hashtagService = hashtagService;
+        this.spaceService = spaceService;
         this.translate = translate;
         this.spModule = userService.getSpModule();
     }
@@ -13862,6 +14361,7 @@ class MatterportTagCopyService {
     async copyTagsFromVisit(sourceSpaceId, targetSpaceId, landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB) {
         let errorCount = 0;
         this.resetLog();
+        this.resetRunState(targetSpaceId);
         try {
             console.log(`Copying Tags from source ${sourceSpaceId} to target ${targetSpaceId}`);
             this.setStepProgress('collecting', 'collecting', 0);
@@ -13879,6 +14379,9 @@ class MatterportTagCopyService {
                 refSource: transform.refSource,
                 refTarget: transform.refTarget
             });
+            // Domains are organisation-scoped, hashtags are space-scoped: both need to know
+            // whether we stay inside the same organisation before anything is remapped.
+            this.sameOrganisation = await this.spacesShareOrganisation(sourceSpaceId, targetSpaceId);
             const sourceSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(sourceSpaceId);
             const targetSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(targetSpaceId);
             this.setStepProgress('collecting', 'collecting', 30);
@@ -13886,7 +14389,7 @@ class MatterportTagCopyService {
                 this.buildNavigationPositionMap(sourceSpaceId, sourceSweepIds),
                 this.buildNavigationPositionMap(targetSpaceId, targetSweepIds)
             ]);
-            const elementIds = {};
+            const elementIds = this.elementIds;
             let sourceTickets = [];
             let sourceEquipments = [];
             let targetTickets = [];
@@ -13902,9 +14405,23 @@ class MatterportTagCopyService {
             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);
+            // Paginated: a space routinely holds more than the 100 features a single AppSync
+            // page returns, and the tail was silently dropped.
+            //
+            // The source list keeps the historical "skip what the operator archived" rule, so
+            // the set of copied features does not change — but the check is now null-safe:
+            // FeatureService.isArchived() dereferences currentMission(spaceID).id and threw a
+            // TypeError when the operator had no mission on the source space (the common case
+            // for an archived v1 space), aborting the whole copy.
+            // The target list is NOT filtered: it only feeds duplicate detection, and an
+            // archived feature is still a feature that exists there.
+            const sourceFeatures = (await this.featureService.getAllFeaturesBySpaceRaw(sourceSpaceId))
+                .filter(feature => !this.isArchivedForOperator(feature, sourceSpaceId));
+            const targetFeatures = await this.featureService.getAllFeaturesBySpaceRaw(targetSpaceId);
             this.setStepProgress('collecting', 'collecting', 75);
+            // Keywords: index both vocabularies now (read-only). The keywords the target space
+            // is missing are created later, POI by POI, only for those actually used.
+            await this.loadHashtagIndex(sourceSpaceId, targetSpaceId);
             if (this.spModule == SpModule.IMMO) {
                 sourceMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId);
                 targetMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId);
@@ -13912,12 +14429,44 @@ class MatterportTagCopyService {
             this.setStepProgress('collecting', 'collecting', 90);
             const sourcePoisAll = await this.poiService.getPoisByMatterportSweeps(sourceSweepIds);
             const targetPoisAll = await this.poiService.getPoisByMatterportSweeps(targetSweepIds);
+            // A POI is "owned" by an element (ticket, equipment, 3D object, feature, measurement)
+            // when its elementID points at one. Those POIs are created by their element's phase,
+            // which is the only place that knows the element's NEW id — so they must be excluded
+            // from the standalone phase, otherwise every feature ends up with two POIs: one
+            // correctly linked but stripped of its tag metadata, and one carrying the metadata
+            // but still pointing at the source space's element.
+            //
+            // Ownership is recognised by TWO independent criteria, and either one is enough to
+            // keep a POI out of the standalone phase:
+            //
+            //  - its type is one an element phase is responsible for. This is the historical
+            //    rule and it must be kept: a POI of that type whose element was NOT collected
+            //    (deleted ticket, equipment outside the current filter, ...) is an orphan, and
+            //    copying it standalone would recreate it with an elementID still pointing into
+            //    the source space — an orphan the previous version correctly refused to copy.
+            //  - its elementID belongs to an element we actually collected. This is the added
+            //    rule, needed because the type alone is not a reliable discriminator: historical
+            //    data also holds INFORMATION/ROOM POIs bound to a feature, which the type test
+            //    lets through and which would end up duplicated.
             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));
+            for (const owner of [...sourceTickets, ...sourceEquipments, ...sourceObjects3D, ...sourceFeatures]) {
+                if (owner?.id) {
+                    this.handledElementIds.add(owner.id);
+                }
+            }
+            for (const measurement of sourceMeasurements) {
+                // a measurement POI is bound to the measurement's Comment, not to the measurement
+                if (measurement?.comment?.id) {
+                    this.handledElementIds.add(measurement.comment.id);
+                }
+            }
+            const isOwnedByAnElement = (poi) => handledPoiTypes.has(poi.type)
+                || (!!poi.elementID && this.handledElementIds.has(poi.elementID));
+            const sourcePois = sourcePoisAll.filter(p => !isOwnedByAnElement(p));
+            const targetPois = targetPoisAll.filter(p => !!p);
             this.setStepProgress('collecting', 'collecting', 100);
             const totalOverall = sourceTickets.length + sourceEquipments.length + sourcePois.length
                 + sourceObjects3D.length + sourceFeatures.length + sourceMeasurements.length;
@@ -13938,7 +14487,7 @@ class MatterportTagCopyService {
                 for (let i = 0; i < sourceTickets.length; i++) {
                     const sourceObj = sourceTickets[i];
                     try {
-                        const existsInTarget = this.matchesExisting(sourceObj, targetTickets);
+                        const existsInTarget = this.matchesExisting(sourceObj, targetTickets, (t) => [t.title, t.description]);
                         if (!existsInTarget) {
                             const rawSource = sourceObj;
                             const ticketInput = {
@@ -13953,28 +14502,51 @@ class MatterportTagCopyService {
                                 read: rawSource.read || null,
                                 projectID: rawSource.projectID || null,
                                 problemCode: rawSource.problemCode || null,
-                                archivedForMissionID: rawSource.archivedForMissionID || null,
+                                // Missions are per-space: a source mission id designates nobody in
+                                // the target space. Carrying the list over would look like real data
+                                // while hiding the item from no one — reset it, as for features.
+                                archivedForMissionID: null,
                                 spaceID: targetSpaceId,
+                                // Remapped in the second pass below, once every ticket exists.
                                 parentID: null,
-                                domainID: null,
+                                // Domains are organisation-scoped, like for equipments and features.
+                                domainID: this.sameOrganisation ? (rawSource.domainID || null) : 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);
+                            // Attachments of the ticket (photos of the incident, documents...).
+                            // They were never copied at all: a duplicated ticket arrived stripped
+                            // of every piece of evidence attached to it.
+                            if (createdObj) {
+                                let sourceComments = [];
+                                try {
+                                    sourceComments = await this.commentService.getAllCommentsForTicket(sourceObj.id);
+                                }
+                                catch (commentsFetchError) {
+                                    console.warn(`Falling back to the embedded comment list for ticket "${rawSource.title}":`, commentsFetchError);
+                                    sourceComments = (sourceObj.comments?.items || []).filter(c => !!c);
+                                }
+                                for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {
+                                    try {
+                                        const created = await this.copyCommentForTicket(sourceComment, createdObj.id, targetSpaceId, targetMissionId);
+                                        if (created?.id && sourceComment.id) {
+                                            this.commentIds.set(sourceComment.id, created.id);
+                                        }
+                                    }
+                                    catch (attachmentError) {
+                                        console.error(`Error copying attachment "${sourceComment?.title}" for ticket "${sourceObj?.title}":`, attachmentError);
+                                        errorCount++;
+                                        this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || sourceComment?.id, {
+                                            feature: rawSource.title || sourceObj.id
+                                        });
+                                    }
+                                }
+                            }
+                            for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {
+                                await this.createCopiedPoi(sourcePoi, createdObj.id, sourceNavPositions, targetNavPositions, transform);
                             }
                         }
                     }
@@ -13988,26 +14560,69 @@ class MatterportTagCopyService {
                     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)
+                // Second pass: restore the ticket hierarchy. `parentID` had to be nulled during
+                // creation (the parent may not have existed yet) and was then never restored, so
+                // every sub-ticket came out detached. Same rule as for sub-equipments: a parent
+                // with no copied counterpart is dropped rather than left pointing at the source
+                // space's ticket.
+                for (const sourceObj of sourceTickets) {
+                    const rawSource = sourceObj;
+                    const newId = elementIds[sourceObj.id];
+                    const newParentId = rawSource.parentID ? elementIds[rawSource.parentID] : null;
+                    if (newId && newParentId) {
+                        try {
+                            await this.ticketService.updateTicket({ id: newId, parentID: newParentId });
+                        }
+                        catch (parentError) {
+                            console.error(`Error remapping the parent ticket of "${sourceObj?.title}":`, parentError);
+                            errorCount++;
+                            this.logCopyItemError(parentError, 'errorTicket', sourceObj?.title || sourceObj?.id);
+                        }
+                    }
+                }
+                // EQUIPMENTS (identity, POI, PHOTO and NOTES/documents all copied — files
+                // physically duplicated in S3 first, so the copy stays independent from the source)
+                //
+                // CAREFUL: the Equipment model has NO `title` and NO `description` column. It
+                // identifies itself with `name` (String! — required) and annotates itself with
+                // `annotation`. Reading `rawSource.title` therefore always yielded undefined and
+                // the required `name` was never sent, which AppSync rejected with
+                // "Variable 'input' has coerced Null value for NonNull type 'String!'".
                 for (let i = 0; i < sourceEquipments.length; i++) {
                     const sourceObj = sourceEquipments[i];
                     try {
-                        const existsInTarget = this.matchesExisting(sourceObj, targetEquipments);
+                        // Equipment has no `title`/`description`: it identifies itself by name, and by
+                        // serial number when one is recorded.
+                        const existsInTarget = this.matchesExisting(sourceObj, targetEquipments, (e) => [e.name, e.serialNumber]);
                         if (!existsInTarget) {
                             const rawSource = sourceObj;
                             let copiedPhotoKey = null;
                             if (rawSource.photo) {
-                                copiedPhotoKey = await this.copyS3KeyIfPresent(rawSource.photo, `equipment photo "${rawSource.title}"`);
+                                copiedPhotoKey = await this.copyS3KeyIfPresent(rawSource.photo, `equipment photo "${rawSource.name}"`);
                             }
                             const equipmentInput = {
-                                title: rawSource.title,
+                                name: rawSource.name,
+                                annotation: rawSource.annotation ?? null,
                                 status: rawSource.status,
-                                description: rawSource.description,
-                                archivedForMissionID: rawSource.archivedForMissionID || null,
+                                // Full identity of the equipment — all of these were dropped
+                                family: rawSource.family ?? null,
+                                sku: rawSource.sku ?? null,
+                                serialNumber: rawSource.serialNumber ?? null,
+                                manufacturer: rawSource.manufacturer ?? null,
+                                installDate: rawSource.installDate ?? null,
+                                warrantyEndDate: rawSource.warrantyEndDate ?? null,
+                                metadata: rawSource.metadata ?? null,
+                                isCreatedByAI: rawSource.isCreatedByAI ?? null,
+                                // Missions are per-space: a source mission id designates nobody in
+                                // the target space. Carrying the list over would look like real data
+                                // while hiding the item from no one — reset it, as for features.
+                                archivedForMissionID: null,
                                 spaceID: targetSpaceId,
-                                domainID: null,
+                                // Domains are organisation-scoped, like for features and POIs.
+                                domainID: this.sameOrganisation ? (rawSource.domainID || null) : null,
                                 photo: copiedPhotoKey,
+                                // `subequipmentsIDs` is deliberately absent: it is remapped to the
+                                // copied equipments in the second pass, once they all exist.
                             };
                             const createdObj = await this.equipmentService.createEquipment(equipmentInput, null, null);
                             if (createdObj && createdObj.id) {
@@ -14017,38 +14632,35 @@ class MatterportTagCopyService {
                             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);
+                                        // A note without a file is still a note: it carries a type
+                                        // and its signature/expiry dates. Skipping it, as was done
+                                        // before, silently dropped those records entirely.
+                                        const copiedKey = sourceNote.attachment
+                                            ? await this.copyS3KeyIfPresent(sourceNote.attachment, `equipment note for "${sourceObj?.name}"`)
+                                            : null;
+                                        await this.equipmentService.createNoteWithExistingAttachment(createdObj.id, copiedKey, sourceNote.type, targetMissionId, {
+                                            signDate: sourceNote.signDate ?? null,
+                                            expirationDate: sourceNote.expirationDate ?? null
+                                        });
                                     }
                                     catch (noteError) {
-                                        console.error(`Error copying note for equipment "${sourceObj?.title}":`, noteError);
+                                        console.error(`Error copying note for equipment "${sourceObj?.name}":`, noteError);
                                         errorCount++;
-                                        this.logCopyItemError(noteError, 'errorEquipmentNote', sourceObj?.title || sourceObj?.id);
+                                        this.logCopyItemError(noteError, 'errorEquipmentNote', sourceObj?.name || sourceObj?.id, {
+                                            equipment: sourceObj?.name || 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);
+                            for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {
+                                await this.createCopiedPoi(sourcePoi, createdObj.id, sourceNavPositions, targetNavPositions, transform);
                             }
                         }
                     }
                     catch (itemError) {
-                        console.error(`Error copying equipment "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
+                        console.error(`Error copying equipment "${sourceObj?.name}" (id: ${sourceObj?.id}):`, itemError);
                         errorCount++;
-                        this.logCopyItemError(itemError, 'errorEquipment', sourceObj?.title || sourceObj?.id);
+                        this.logCopyItemError(itemError, 'errorEquipment', sourceObj?.name || sourceObj?.id);
                     }
                     processedOverall++;
                     emitProgress('equipments', i + 1, sourceEquipments.length);
@@ -14071,54 +14683,16 @@ class MatterportTagCopyService {
                                 await this.equipmentService.updateEquipment({ id: newId, subequipmentsIDs: remapped });
                             }
                             catch (subEquipError) {
-                                console.error(`Error remapping sub-equipments for "${sourceObj?.title}":`, subEquipError);
+                                console.error(`Error remapping sub-equipments for "${sourceObj?.name}":`, subEquipError);
                                 errorCount++;
-                                this.logCopyItemError(subEquipError, 'errorEquipmentSubEquip', sourceObj?.title || sourceObj?.id);
+                                this.logCopyItemError(subEquipError, 'errorEquipmentSubEquip', sourceObj?.name || sourceObj?.id, {
+                                    equipment: sourceObj?.name || 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];
@@ -14126,8 +14700,16 @@ class MatterportTagCopyService {
                     const existsInTarget = targetObjects3D.some(targetObj => targetObj.name === sourceObj.name);
                     if (!existsInTarget) {
                         const rawSource = sourceObj;
+                        // `path` means two different things depending on `s3Bucket`, exactly as the
+                        // viewer reads it (see viewer.component.ts and matterport-object3d.service.ts):
+                        //  - s3Bucket === true  -> a key of a model file uploaded to S3, ours to duplicate;
+                        //  - otherwise          -> a reference into the 3D object library shipped with
+                        //    the application ("3DObjects/objects/cube.dae" -> assets/3Dobjects/...),
+                        //    which exists in every space and must be reused verbatim.
+                        // Copying unconditionally meant every library object failed with NoSuchKey and
+                        // the whole 3D object was skipped, model AND POI.
                         let copiedPath = rawSource.path;
-                        if (rawSource.path) {
+                        if (rawSource.path && rawSource.s3Bucket) {
                             copiedPath = await this.copyS3KeyIfPresent(rawSource.path, `3D object "${rawSource.name}"`);
                         }
                         /**
@@ -14157,39 +14739,65 @@ class MatterportTagCopyService {
                             // Ensure we return valid numbers
                             return array.map(n => isNaN(n) ? 0 : n);
                         };
+                        // This service is shared, but the two applications do NOT deploy the same
+                        // Object3D schema: `viewFrustum` exists only in smarterplan, and `scale`
+                        // is [Float] there but a plain Float in museum. Sending the smarterplan
+                        // shape to museum was rejected with "The variables input contains a field
+                        // that is not defined for input object type 'CreateObject3DInput'".
+                        //
+                        // The input therefore MIRRORS the source record instead of imposing a
+                        // shape: source and target live in the same deployment, so whatever the
+                        // source carries is exactly what the target accepts.
                         const object3DInput = {
                             path: copiedPath,
+                            // Tells the viewer how to interpret `path`. Dropping it turned an
+                            // S3-hosted model into a library reference on the copy, which the
+                            // viewer then tried to resolve against assets/ and failed to load.
+                            s3Bucket: !!rawSource.s3Bucket,
                             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])
+                            rotation: toFloatArray(rawSource.rotation, [0, 0, 0])
                         };
-                        // Debugging: Inspect the exact object sent to the mutation
-                        console.log(`[DEBUG] Sending Object3D "${rawSource.name}" to API:`, JSON.stringify(object3DInput));
+                        if ('viewFrustum' in rawSource) {
+                            object3DInput.viewFrustum = !!rawSource.viewFrustum;
+                        }
+                        // Scale keeps the source's own shape: a list stays a list, a scalar stays
+                        // a scalar. An absent scale is left unset rather than invented, so the copy
+                        // renders exactly like the original.
+                        if (Array.isArray(rawSource.scale)) {
+                            object3DInput.scale = toFloatArray(rawSource.scale, [1, 1, 1]);
+                        }
+                        else if (rawSource.scale !== null && rawSource.scale !== undefined) {
+                            const scalarScale = parseFloat(rawSource.scale);
+                            object3DInput.scale = Number.isNaN(scalarScale) ? 1 : scalarScale;
+                        }
                         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);
+                        for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {
+                            await this.createCopiedPoi(sourcePoi, createdObj.id, sourceNavPositions, targetNavPositions, transform);
                         }
                     }
                 }
                 catch (itemError) {
+                    // The backend can deny creation of this whole model to the signed-in account
+                    // (in MUSEUM, Object3D only grants get/list to userPools). The denial is not
+                    // per-item, so every remaining object would fail identically: report it once,
+                    // as a permission problem rather than a copy error, and stop the phase instead
+                    // of firing one doomed mutation per object.
+                    if (this.isUnauthorized(itemError)) {
+                        const remaining = sourceObjects3D.length - i;
+                        console.warn(`[MatterportTagCopyService] Not allowed to create 3D objects in the target space, skipping ${remaining} of them.`, itemError);
+                        errorCount++;
+                        this.logItemError('errorObjects3dNotAllowed', { count: remaining });
+                        processedOverall += remaining;
+                        emitProgress('objects3d', sourceObjects3D.length, sourceObjects3D.length);
+                        this.setStepProgress('objects3d', 'objects3d', 100);
+                        break;
+                    }
                     console.error(`Error copying object3D "${sourceObj?.name}":`, itemError);
                     errorCount++;
                     this.logCopyItemError(itemError, 'errorObject3d', sourceObj?.name || sourceObj?.id);
@@ -14199,76 +14807,86 @@ class MatterportTagCopyService {
                 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)
+            // FEATURES — the "POI" of the MUSEUM module: its own record (title, index, locale,
+            // keywords), its media set (one Comment per image/video/audio/document/link/text)
+            // and its POI record (the pastille: icon, tag description, cover image).
+            // Everything is copied here, files physically duplicated in S3 first.
             for (let i = 0; i < sourceFeatures.length; i++) {
                 const sourceObj = sourceFeatures[i];
                 try {
-                    const existsInTarget = this.matchesExisting(sourceObj, targetFeatures);
+                    const existsInTarget = this.matchesExisting(sourceObj, targetFeatures, (f) => [f.title, f.description]);
                     if (!existsInTarget) {
                         const rawSource = sourceObj;
+                        // Resolved just before the write: a keyword is only created in the target
+                        // space when the POI carrying it is about to be created.
+                        const resolvedHashtags = await this.resolveHashtagIds(rawSource.hashtags, targetSpaceId);
                         const featureInput = {
                             title: rawSource.title,
                             shortDescription: rawSource.shortDescription,
                             level: rawSource.level,
                             type: rawSource.type,
-                            archivedForMissionID: rawSource.archivedForMissionID || null,
+                            // `index` drives the ordering of the POI in the space's list, in the
+                            // lateral menu and in the guided tour. Dropping it forced a full manual
+                            // renumbering of every copied POI.
+                            index: rawSource.index ?? null,
+                            // Missions are per-space: source mission ids mean nothing in the target
+                            // space, so an archive list carried over would hide POIs from nobody
+                            // while looking like real data. Reset instead.
+                            archivedForMissionID: null,
                             stripeProductID: rawSource.stripeProductID || null,
                             stripePriceID: rawSource.stripePriceID || null,
                             bookingPriceMetadata: rawSource.bookingPriceMetadata || null,
                             locale: rawSource.locale || null,
-                            hashtags: rawSource.hashtags || null,
+                            // Hashtags are space-scoped records: the ids must be translated to the
+                            // equivalent hashtags of the target space (created on demand).
+                            hashtags: resolvedHashtags,
                             description: rawSource.description || null,
-                            domainID: null,
+                            // Domains are organisation-scoped, so the category survives a copy
+                            // inside one organisation and only has to be dropped across two.
+                            domainID: this.sameOrganisation ? (rawSource.domainID || null) : null,
                             spaceID: targetSpaceId,
                             ownerMissionID: targetMissionId
                         };
                         const createdObj = await this.featureService.createFeature(featureInput);
                         if (createdObj && createdObj.id) {
                             elementIds[sourceObj.id] = createdObj.id;
+                            // The feature exists: its keywords are now genuinely referenced and
+                            // must survive the end-of-run cleanup.
+                            this.markHashtagsUsed(resolvedHashtags);
                         }
-                        if (createdObj && sourceObj.comments?.items && sourceObj.comments.items.length > 0) {
-                            for (const sourceComment of sourceObj.comments.items) {
+                        if (createdObj) {
+                            // Read the media set through its own paginated query: the `comments`
+                            // connection embedded in FeaturesBySpace is capped at 100 items and its
+                            // nextToken was never followed, so rich POIs lost attachments silently.
+                            let sourceComments = [];
+                            try {
+                                sourceComments = await this.commentService.getAllCommentsForFeature(sourceObj.id);
+                            }
+                            catch (commentsFetchError) {
+                                console.warn(`Falling back to the embedded comment list for feature "${rawSource.title}":`, commentsFetchError);
+                                sourceComments = (sourceObj.comments?.items || []).filter(c => !!c);
+                            }
+                            for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {
                                 try {
-                                    const rawComment = sourceComment;
-                                    let copiedAnnexe = null;
-                                    if (rawComment.annexe) {
-                                        copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `feature attachment "${rawComment.title}"`);
+                                    const created = await this.copyCommentForFeature(sourceComment, createdObj.id, targetSpaceId, targetMissionId);
+                                    if (created?.id && sourceComment.id) {
+                                        this.commentIds.set(sourceComment.id, created.id);
                                     }
-                                    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);
+                                    this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || sourceComment?.id, {
+                                        feature: rawSource.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);
+                            // Every POI of the feature, not only the first one: a feature may be
+                            // pinned at several places, and only this phase knows the new element id.
+                            const sourceFeaturePois = (sourceObj.pois?.items || []).filter(p => !!p);
+                            for (const sourcePoi of sourceFeaturePois) {
+                                await this.createCopiedPoi(sourcePoi, createdObj.id, sourceNavPositions, targetNavPositions, transform);
+                            }
                         }
                     }
                 }
@@ -14297,12 +14915,17 @@ class MatterportTagCopyService {
                             }
                             const commentInput = {
                                 title: rawComment.title,
+                                description: rawComment.description ?? null,
+                                metadata: rawComment.metadata ?? null,
                                 type: CommentType.MEASURE,
                                 dimensions: rawComment.dimensions || null,
                                 annexe: copiedAnnexe,
                                 spaceID: targetSpaceId,
                             };
                             const createdComment = await this.commentService.createComment(commentInput);
+                            if (createdComment && createdComment.id && rawComment.id) {
+                                this.commentIds.set(rawComment.id, createdComment.id);
+                            }
                             if (createdComment && sourceMeasurement.poi) {
                                 const targetSweepId = this.findClosestTargetSweepId(sourceMeasurement.poi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
                                 const adjustedPosition = this.getAdjustedPositionOnly(sourceMeasurement.poi.coordinate, transform);
@@ -14310,7 +14933,9 @@ class MatterportTagCopyService {
                                     coordinate: JSON.stringify(adjustedPosition),
                                     type: PoiType.MEASURE,
                                     elementID: createdComment.id,
-                                    metadata: sourceMeasurement.poi.metadata,
+                                    // Same treatment as any other POI: the source's Matterport tag
+                                    // SID must not travel, and the stem normal has to be rotated.
+                                    metadata: this.getAdjustedPoiMetadata(sourceMeasurement.poi.metadata, transform),
                                     matterportSweepID: targetSweepId
                                 };
                                 await this.poiService.createPOIForSpaceID(poiInput);
@@ -14328,6 +14953,36 @@ class MatterportTagCopyService {
                     this.setStepProgress('measurements', 'measurements', pct);
                 }
             }
+            // POIS — standalone ones only: every POI owned by an element was already created by
+            // that element's phase, with the element's NEW id.
+            //
+            // This phase runs LAST on purpose. It used to run third, before 3D objects, features
+            // and measurements existed in the target space, so `elementIds` and `commentIds` were
+            // still empty when it needed them: elementID stayed pointing at the source space and
+            // tagImageID (a reference to a Comment record) could never be resolved.
+            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 elementID = sourcePoi.elementID
+                            ? (elementIds[sourcePoi.elementID] || sourcePoi.elementID)
+                            : sourcePoi.elementID;
+                        await this.createCopiedPoi(sourcePoi, elementID, sourceNavPositions, targetNavPositions, transform);
+                    }
+                }
+                catch (itemError) {
+                    console.error(`Error copying POI (sweep: ${sourcePoi?.matterportSweepID}):`, itemError);
+                    errorCount++;
+                    this.logCopyItemError(itemError, 'errorPoi', sourcePoi?.matterportSweepID, {
+                        sweep: 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);
+            }
             this.copyProgress$.next({
                 phase: 'done',
                 processedInPhase: 0, totalInPhase: 0,
@@ -14345,6 +15000,12 @@ class MatterportTagCopyService {
             this.copyProgress$.next(null);
             return false;
         }
+        finally {
+            // Every exit path — success, partial success, or general failure — gives back the
+            // keywords this run created but no copied POI ended up using. Placed in `finally`
+            // so an exception thrown mid-copy cannot leave them behind either.
+            await this.cleanupUnusedCreatedHashtags();
+        }
     }
     //
     // ---------- Progress / log helpers ----------
@@ -14373,6 +15034,20 @@ class MatterportTagCopyService {
         this.errorSeq = 0;
         this.copyLog$.next([]);
     }
+    /** Clears every id map carried over from a previous run. The service is a root-level
+     *  singleton, so leftover mappings would silently link a new copy to records created
+     *  during the previous one. */
+    resetRunState(targetSpaceId) {
+        this.elementIds = {};
+        this.commentIds = new Map();
+        this.sourceHashtagNames = new Map();
+        this.targetHashtagIdsByName = new Map();
+        this.createdHashtagIds = new Set();
+        this.usedHashtagIds = new Set();
+        this.handledElementIds = new Set();
+        this.sameOrganisation = false;
+        this.targetSpaceId = targetSpaceId;
+    }
     /** 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}`);
@@ -14386,28 +15061,408 @@ class MatterportTagCopyService {
     /** 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) {
+     *  investigate the same way a network/permission error is.
+     *  `extraParams` carries the placeholders a few keys need on top of {{name}}/{{error}}
+     *  (e.g. errorFeatureAttachment's {{feature}}, errorPoi's {{sweep}}), which used to be
+     *  rendered as raw "{{feature}}" text in the log. */
+    logCopyItemError(error, genericKey, itemLabel, extraParams = {}) {
         if (error instanceof MissingS3FileError) {
             this.logItemError('errorMissingS3FileSkipped', {
+                ...extraParams,
                 name: itemLabel,
                 file: error.sourceKey
             });
         }
         else {
-            this.logItemError(genericKey, { name: itemLabel, error: toErrorMessage(error) });
+            this.logItemError(genericKey, { ...extraParams, name: itemLabel, error: toErrorMessage(error) });
+        }
+    }
+    /**
+     * Null-safe equivalent of FeatureService.isArchived(): true when the operator has archived
+     * this feature on that space. "No mission on the space" answers false (nothing archived)
+     * instead of throwing, which is what made a copy from a space the operator is not a member
+     * of fail outright.
+     */
+    isArchivedForOperator(feature, spaceId) {
+        const archivedFor = feature?.archivedForMissionID;
+        if (!archivedFor || archivedFor.length === 0) {
+            return false;
         }
+        const mission = this.userService.currentMission(spaceId);
+        return mission?.id ? archivedFor.includes(mission.id) : false;
+    }
+    //
+    // ---------- Cross-space reference remapping ----------
+    //
+    /**
+     * True when both spaces belong to the same organisation.
+     * Domains (POI/Feature categories) are organisation-scoped records with no spaceID, so
+     * a domainID stays meaningful inside one organisation and only becomes a dangling
+     * reference across two. A failed lookup answers "no": dropping a category is recoverable,
+     * pointing at another organisation's domain is not.
+     */
+    async spacesShareOrganisation(sourceSpaceId, targetSpaceId) {
+        try {
+            const [sourceSpace, targetSpace] = await Promise.all([
+                this.spaceService.getSpace(sourceSpaceId),
+                this.spaceService.getSpace(targetSpaceId)
+            ]);
+            const sourceOrg = sourceSpace?.organisationID;
+            const targetOrg = targetSpace?.organisationID;
+            return !!sourceOrg && !!targetOrg && sourceOrg === targetOrg;
+        }
+        catch (error) {
+            console.warn('[MatterportTagCopyService] Could not compare the spaces\' organisations, categories will be dropped:', error);
+            return false;
+        }
+    }
+    /** Normalised lookup key for a hashtag name, so "Moyen Âge" and "moyen âge " match. */
+    hashtagKey(name) {
+        return name.trim().toLowerCase();
+    }
+    /**
+     * READ-ONLY indexing of both spaces' hashtags. Creates nothing.
+     *
+     * `Feature.hashtags` stores Hashtag *ids*, and a Hashtag is a per-space record, so the
+     * ids have to be translated by name. The translation table is built here; the missing
+     * keywords are created later, one at a time, only when a POI that actually uses them is
+     * about to be written (see resolveHashtagIds()).
+     */
+    async loadHashtagIndex(sourceSpaceId, targetSpaceId) {
+        let sourceHashtags = [];
+        let targetHashtags = [];
+        try {
+            [sourceHashtags, targetHashtags] = await Promise.all([
+                this.hashtagService.listHashtagsForSpace(sourceSpaceId),
+                this.hashtagService.listHashtagsForSpace(targetSpaceId)
+            ]);
+        }
+        catch (error) {
+            console.warn('[MatterportTagCopyService] Could not read the hashtags, keywords will be dropped:', error);
+            return;
+        }
+        for (const hashtag of sourceHashtags || []) {
+            if (hashtag?.id && hashtag.name) {
+                this.sourceHashtagNames.set(hashtag.id, hashtag.name);
+            }
+        }
+        for (const hashtag of targetHashtags || []) {
+            if (hashtag?.id && hashtag.name) {
+                this.targetHashtagIdsByName.set(this.hashtagKey(hashtag.name), hashtag.id);
+            }
+        }
+    }
+    /**
+     * Translates one feature's hashtag ids into target-space ids, creating on the fly the
+     * keywords the target space does not have yet.
+     *
+     * Creation is LAZY on purpose. Doing it up front, for the whole source vocabulary, meant
+     * that a copy which failed or was closed halfway left behind keywords no POI referenced —
+     * pollution the operator had to clean up by hand. Here a keyword is only ever written
+     * when a POI that carries it is about to be created, so an interrupted copy stops
+     * creating keywords at the same POI it stops creating content.
+     *
+     * The residual window (keyword created, then createFeature fails) is closed by
+     * markHashtagsUsed() + cleanupUnusedCreatedHashtags().
+     *
+     * A keyword that can neither be found nor created is dropped rather than left as a
+     * dangling id.
+     */
+    async resolveHashtagIds(sourceHashtagIds, targetSpaceId) {
+        if (!sourceHashtagIds || sourceHashtagIds.length === 0) {
+            return null;
+        }
+        const resolved = [];
+        for (const sourceId of sourceHashtagIds) {
+            if (!sourceId) {
+                continue;
+            }
+            const name = this.sourceHashtagNames.get(sourceId);
+            if (!name) {
+                // the source id points at a hashtag that no longer exists — nothing to carry over
+                continue;
+            }
+            const key = this.hashtagKey(name);
+            let targetId = this.targetHashtagIdsByName.get(key);
+            if (!targetId) {
+                try {
+                    const created = await this.hashtagService.createHashtagForSpace(name, targetSpaceId);
+                    targetId = created?.id;
+                    if (targetId) {
+                        this.targetHashtagIdsByName.set(key, targetId);
+                        this.createdHashtagIds.add(targetId);
+                    }
+                }
+                catch (error) {
+                    console.warn(`[MatterportTagCopyService] Could not create the hashtag "${name}" in the target space:`, error);
+                    continue;
+                }
+            }
+            if (targetId && !resolved.includes(targetId)) {
+                resolved.push(targetId);
+            }
+        }
+        return resolved.length > 0 ? resolved : null;
+    }
+    /** Records that these hashtags are now referenced by a feature that really exists, so
+     *  the end-of-run cleanup leaves them alone. */
+    markHashtagsUsed(hashtagIds) {
+        for (const id of hashtagIds || []) {
+            this.usedHashtagIds.add(id);
+        }
+    }
+    /**
+     * Deletes the hashtags this run created that no copied POI ended up referencing.
+     *
+     * Runs on every exit path — success, general failure, or exception — so the target space
+     * never keeps keywords that came from an aborted copy. Only ids created by THIS run are
+     * ever considered: a pre-existing keyword of the target space is never touched, even if
+     * no copied POI uses it.
+     */
+    async cleanupUnusedCreatedHashtags() {
+        const orphans = [...this.createdHashtagIds].filter(id => !this.usedHashtagIds.has(id));
+        if (orphans.length === 0) {
+            return;
+        }
+        console.log(`[MatterportTagCopyService] Removing ${orphans.length} keyword(s) created but left unused by this copy.`);
+        for (const hashtagId of orphans) {
+            try {
+                await this.hashtagService.deleteHashtagById(hashtagId);
+                this.createdHashtagIds.delete(hashtagId);
+            }
+            catch (error) {
+                // Cleanup is best-effort: a leftover keyword is harmless next to a failed copy,
+                // and must never be the reason the whole operation reports a failure.
+                console.warn(`[MatterportTagCopyService] Could not remove the unused keyword "${hashtagId}":`, error);
+            }
+        }
+    }
+    //
+    // ---------- Media content (Comments) ----------
+    //
+    /**
+     * Orders a feature's media set exactly the way the UI will read it back, and repairs
+     * the ordering key when the source data cannot express the user's intended order.
+     *
+     * The viewer sorts each media family on its own (`setImages`, `setVideos`, `setAudio`,
+     * `setDocuments`, ... all do `.sort((a, b) => a.index - b.index)`), so `index` only has
+     * to be consistent WITHIN a CommentType. The attachment form however defaults `index`
+     * to 1 for every new attachment, so a multi-image POI very often holds several images
+     * all sharing index 1 — or null. Sorting those is left to DynamoDB's arbitrary scan
+     * order, which is why the copy came out in a different order than the original.
+     *
+     * Strategy: sort deterministically (index, then creation date, then id — i.e. the
+     * upload order the user actually saw), and only rewrite the indices of a family when
+     * they are ambiguous (null or duplicated). A family whose indices are already unique
+     * is copied untouched, so a deliberate ordering is never overwritten.
+     */
+    orderCommentsForCopy(comments) {
+        const valid = (comments || []).filter(c => !!c);
+        const byType = new Map();
+        for (const comment of valid) {
+            const key = comment.type || 'UNTYPED';
+            if (!byType.has(key)) {
+                byType.set(key, []);
+            }
+            byType.get(key).push(comment);
+        }
+        const ordered = [];
+        for (const family of byType.values()) {
+            family.sort((a, b) => {
+                const ai = this.orderingIndexOf(a);
+                const bi = this.orderingIndexOf(b);
+                if (ai !== bi) {
+                    return ai - bi;
+                }
+                const ad = this.creationTimeOf(a);
+                const bd = this.creationTimeOf(b);
+                if (ad !== bd) {
+                    return ad - bd;
+                }
+                return String(a.id || '').localeCompare(String(b.id || ''));
+            });
+            const indices = family.map(c => c.index);
+            const isAmbiguous = indices.some(i => i === null || i === undefined)
+                || new Set(indices).size !== indices.length;
+            family.forEach((comment, position) => {
+                comment.__copyIndex = isAmbiguous ? position + 1 : comment.index;
+            });
+            ordered.push(...family);
+        }
+        return ordered;
+    }
+    /** Sort key for a comment's position; a missing index sorts last, not first. */
+    orderingIndexOf(comment) {
+        const index = comment?.index;
+        return index === null || index === undefined || Number.isNaN(Number(index))
+            ? Number.MAX_SAFE_INTEGER
+            : Number(index);
+    }
+    /** Creation timestamp of a comment, used as the tie-breaker: it reflects the order in
+     *  which the user uploaded the media, which is the order they saw. */
+    creationTimeOf(comment) {
+        const createdAt = comment?.createdAt;
+        if (!createdAt) {
+            return 0;
+        }
+        const time = new Date(createdAt).getTime();
+        return Number.isNaN(time) ? 0 : time;
+    }
+    /**
+     * Copies ONE media item (image, video, audio, document, text, link, embed, iframe...)
+     * of a feature, duplicating its file in S3 first when it has one.
+     *
+     * Every column of the Comment model is carried over. `description` and `metadata` were
+     * previously dropped, which emptied the captions of images/videos, the body of TEXT
+     * items — where the whole content lives, since a TEXT comment has no file — and any
+     * per-media settings stored in metadata.
+     */
+    async copyCommentForFeature(sourceComment, targetFeatureId, targetSpaceId, targetMissionId) {
+        return this.copyComment(sourceComment, targetSpaceId, targetMissionId, { featureID: targetFeatureId });
+    }
+    /** Same, for an attachment carried by a ticket rather than by a feature. */
+    async copyCommentForTicket(sourceComment, targetTicketId, targetSpaceId, targetMissionId) {
+        return this.copyComment(sourceComment, targetSpaceId, targetMissionId, { ticketID: targetTicketId });
+    }
+    /** Shared body of the two above: `owner` carries whichever foreign key links the copy back
+     *  to its new parent, everything else is identical. */
+    async copyComment(sourceComment, targetSpaceId, targetMissionId, owner) {
+        const rawComment = sourceComment;
+        let copiedAnnexe = null;
+        if (rawComment.annexe) {
+            copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `attachment "${rawComment.title}"`);
+        }
+        const commentInput = {
+            title: rawComment.title,
+            description: rawComment.description ?? null,
+            metadata: rawComment.metadata ?? null,
+            type: rawComment.type,
+            annexe: copiedAnnexe,
+            externalLink: rawComment.externalLink || null,
+            dimensions: rawComment.dimensions || null,
+            index: rawComment.__copyIndex ?? rawComment.index ?? null,
+            shownInTag: rawComment.shownInTag,
+            isCoverImage: rawComment.isCoverImage,
+            spaceID: targetSpaceId,
+            ownerID: targetMissionId,
+            ...owner
+        };
+        return this.commentService.createComment(commentInput);
+    }
+    //
+    // ---------- POI creation ----------
+    //
+    /**
+     * Creates the target-space copy of a source POI, with EVERY column of the POI model.
+     *
+     * Single entry point for all phases: the element phases (ticket, equipment, 3D object,
+     * feature, measurement) used to build their POI inline with only 5 fields — coordinate,
+     * type, elementID, metadata, sweep — which is precisely how museum POIs lost their
+     * pastille: `tagDescription` (the popup text), `tagIcon` (the custom icon) and
+     * `tagImageID` (the pastille's image) never left the source space.
+     */
+    async createCopiedPoi(sourcePoi, elementID, sourceNavPositions, targetNavPositions, transform) {
+        const raw = sourcePoi;
+        const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+        const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+        const poiInput = {
+            coordinate: adjustedCoordinate === null || adjustedCoordinate === undefined
+                ? null
+                : JSON.stringify(adjustedCoordinate),
+            type: sourcePoi.type,
+            elementID: elementID ?? null,
+            matterportSweepID: targetSweepId,
+            // --- pastille (tag popup) ---
+            tagDescription: sourcePoi.tagDescription ?? null,
+            tagIcon: await this.duplicateTagIcon(sourcePoi.tagIcon),
+            tagImageID: this.resolveTagImageID(sourcePoi.tagImageID),
+            // --- rendering / visibility flags, carried over verbatim ---
+            specific: raw.specific ?? null,
+            private: raw.private ?? null,
+            global: raw.global ?? null,
+            level: raw.level ?? null,
+            role: raw.role ?? null,
+            category: raw.category ?? null,
+            domainID: this.sameOrganisation ? (raw.domainID || null) : null,
+            // --- Matterport anchoring ---
+            metadata: this.getAdjustedPoiMetadata(sourcePoi.metadata, transform)
+        };
+        return this.poiService.createPOIForSpaceID(poiInput);
+    }
+    /**
+     * Adapts a POI's `metadata` (see MattertagData.getMetadataString(): { icon, normal, sid })
+     * to the target space.
+     *
+     *  - `sid` is the id of the Mattertag inside the SOURCE Matterport model. Carried over,
+     *    the viewer tries to re-create the target's tag with an id belonging to another
+     *    model ("already in use"), so the pastille fails to attach. It is dropped: the
+     *    viewer then allocates a fresh sid on first render.
+     *  - `normal` is the stem direction. It is a direction, so only the rotation applies
+     *    (never the translation); without it, a copied pastille points into the wall
+     *    whenever the two models are not aligned on the same axis.
+     *  - `icon` and anything else is kept as-is.
+     */
+    getAdjustedPoiMetadata(metadata, transform) {
+        if (!metadata) {
+            return metadata ?? null;
+        }
+        try {
+            const parsed = JSON.parse(metadata);
+            if (!parsed || typeof parsed !== 'object') {
+                return metadata;
+            }
+            if (parsed.normal
+                && typeof parsed.normal === 'object'
+                && typeof parsed.normal.x === 'number'
+                && typeof parsed.normal.y === 'number'
+                && typeof parsed.normal.z === 'number') {
+                parsed.normal = applyRigidTransformToDirection(parsed.normal, transform);
+            }
+            delete parsed.sid;
+            return JSON.stringify(parsed);
+        }
+        catch {
+            // Not JSON, or unexpected shape — leave untouched rather than guess.
+            return metadata;
+        }
+    }
+    /**
+     * Resolves a POI's `tagImageID` — which the schema documents as a "connection to
+     * comment.id", i.e. the id of the Comment holding the image shown in the pastille.
+     *
+     * It is NOT an S3 key, so the previous "does it contain a slash?" heuristic never
+     * matched and the value travelled unchanged, leaving every copied pastille pointing at
+     * a Comment of the source space. It is now translated through the comment id map built
+     * while duplicating the media, and dropped when it cannot be resolved (the pastille
+     * then falls back to the feature's cover image instead of a broken reference).
+     */
+    resolveTagImageID(tagImageID) {
+        if (!tagImageID) {
+            return null;
+        }
+        return this.commentIds.get(tagImageID) ?? null;
     }
     //
     // ---------- 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.
+     * Heuristic duplicate-detection: compares several identifying fields together rather than
+     * a single label, to reduce false positives when items share one of them.
+     *
+     * The fields are supplied by the caller because the models do not agree on them. The
+     * previous version hard-coded `title`/`description`, which do not exist on Equipment at
+     * all: both sides read `undefined`, every equipment therefore "matched" every other one,
+     * and a target space holding a single equipment silently caused the whole equipment phase
+     * to copy nothing.
      */
-    matchesExisting(source, targetList) {
-        return targetList.some(t => t.title === source.title && (t.description || null) === (source.description || null));
+    matchesExisting(source, targetList, identity) {
+        const sourceKey = this.identityKey(identity(source));
+        return targetList.some(target => this.identityKey(identity(target)) === sourceKey);
+    }
+    /** Serialises the identifying fields unambiguously, so that ["a", "b"] and ["ab", ""]
+     *  can never produce the same key. */
+    identityKey(parts) {
+        return JSON.stringify(parts.map(part => part ?? ''));
     }
     //
     // ---------- Sweep positions / rigid transform ----------
@@ -14501,10 +15556,12 @@ class MatterportTagCopyService {
     /**
      * Builds a new S3 key for a copied attachment and sanitizes the filename
      * to prevent AWS Amplify SignatureDoesNotMatch errors.
+     * `folderOverride` re-homes the copy into another prefix — used for tag icons, which
+     * are stored per space (`icons-tags/<spaceId>/`) and must follow the target space.
      */
-    buildCopiedAttachmentKey(sourceAnnexe) {
+    buildCopiedAttachmentKey(sourceAnnexe, folderOverride = null) {
         const lastSlash = sourceAnnexe.lastIndexOf('/');
-        const folder = sourceAnnexe.substring(0, lastSlash + 1);
+        const folder = folderOverride ?? 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}_(.+)$/);
@@ -14524,12 +15581,12 @@ class MatterportTagCopyService {
      *   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) {
+    async copyS3KeyIfPresent(key, contextLabel, folderOverride = null) {
         if (!key) {
             return null;
         }
         const sourceKey = this.extractS3KeyFromValue(key);
-        const destKey = this.buildCopiedAttachmentKey(sourceKey);
+        const destKey = this.buildCopiedAttachmentKey(sourceKey, folderOverride);
         // 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 {
@@ -14540,49 +15597,101 @@ class MatterportTagCopyService {
             return copied;
         }
         catch (error) {
-            const isMissingFile = error instanceof MissingS3FileError
-                || error?.code === 'NoSuchKey'
-                || /NoSuchKey|does not exist/i.test(toErrorMessage(error));
-            if (isMissingFile) {
+            if (this.isMissingS3File(error)) {
                 console.warn(`[MatterportTagCopyService] Orphaned S3 reference, skipping item: "${sourceKey}" (${contextLabel})`);
                 throw new MissingS3FileError(sourceKey, contextLabel);
             }
+            // Storage.copy() cannot handle a key holding a space, an accent or a parenthesis:
+            // it puts the key unencoded into `x-amz-copy-source`, which then disagrees with the
+            // signed request. Those files are perfectly readable — only that header is broken —
+            // so fall back to downloading and re-uploading them.
+            if (this.isSignatureMismatch(error)) {
+                console.warn(`[MatterportTagCopyService] Storage.copy() signature mismatch on "${sourceKey}", falling back to download + re-upload.`);
+                try {
+                    const copied = await copyFileInS3ViaDownload(sourceKey, destKey);
+                    if (!copied) {
+                        throw new MissingS3FileError(sourceKey, contextLabel);
+                    }
+                    return copied;
+                }
+                catch (fallbackError) {
+                    if (this.isMissingS3File(fallbackError)) {
+                        throw new MissingS3FileError(sourceKey, contextLabel);
+                    }
+                    throw fallbackError;
+                }
+            }
             throw error;
         }
     }
+    /** True when the failure means the source object simply is not on S3 (orphaned reference). */
+    isMissingS3File(error) {
+        return error instanceof MissingS3FileError
+            || error?.code === 'NoSuchKey'
+            || error?.name === 'NoSuchKey'
+            || /NoSuchKey|does not exist|NotFound/i.test(toErrorMessage(error));
+    }
+    /** True when AppSync refused the operation for lack of permission, as opposed to failing it.
+     *  Nothing can be retried or worked around client-side: the account simply is not allowed
+     *  to write that model, which is a backend authorisation rule (@auth) to change. */
+    isUnauthorized(error) {
+        const message = toErrorMessage(error);
+        return error?.errorType === 'Unauthorized'
+            || /Unauthorized|Not Authorized to access/i.test(message);
+    }
+    /** True for the SigV4 mismatch Storage.copy() raises on keys with special characters. */
+    isSignatureMismatch(error) {
+        return error?.code === 'SignatureDoesNotMatch'
+            || error?.name === 'SignatureDoesNotMatch'
+            || /signature we calculated does not match|SignatureDoesNotMatch/i.test(toErrorMessage(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.
+     * { src, opacity }, per form-feature.component.ts).
+     *
+     * Two behaviours matter here:
+     *  - the copy is re-homed under the TARGET space's icon folder
+     *    (`icons-tags/<targetSpaceId>/`, the layout form-feature.component.ts uploads to).
+     *    Keeping the source folder produced a target space whose icons all lived under
+     *    another space's prefix, so cleaning up the source space broke the copy's icons.
+     *  - a missing icon file is NOT fatal. It used to bubble up as a MissingS3FileError and
+     *    abort the whole POI — losing the pastille, its text and its media because of a
+     *    decorative file. The POI is now created with the icon reference dropped, which
+     *    renders the module's default icon, and a log line reports it.
      */
     async duplicateTagIcon(tagIconRaw) {
         if (!tagIconRaw) {
-            return tagIconRaw;
+            return tagIconRaw ?? null;
         }
+        let parsed;
         try {
-            const parsed = JSON.parse(tagIconRaw);
-            if (parsed && parsed.src) {
-                parsed.src = await this.copyS3KeyIfPresent(parsed.src, 'tag icon');
-            }
-            return JSON.stringify(parsed);
+            parsed = JSON.parse(tagIconRaw);
         }
         catch {
-            // Not JSON, or unexpected shape — leave untouched rather than guess.
+            // Not JSON — 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;
+        if (!parsed || typeof parsed !== 'object' || !parsed.src) {
+            return tagIconRaw;
+        }
+        try {
+            parsed.src = await this.copyS3KeyIfPresent(parsed.src, 'tag icon', this.buildTargetIconFolder());
         }
-        return this.copyS3KeyIfPresent(tagImageID, 'tag image');
+        catch (iconError) {
+            if (!(iconError instanceof MissingS3FileError)) {
+                // A real failure (permissions, network, ...) still aborts the POI: it means
+                // the copy cannot be trusted, unlike a file that is simply already gone.
+                throw iconError;
+            }
+            console.warn(`[MatterportTagCopyService] Tag icon missing on S3, falling back to the default icon: "${iconError.sourceKey}"`);
+            this.logItemError('warningTagIconMissing', { file: iconError.sourceKey });
+            delete parsed.src;
+        }
+        return JSON.stringify(parsed);
+    }
+    /** Icon folder of the space being copied into, matching what the feature form uploads to. */
+    buildTargetIconFolder() {
+        return this.targetSpaceId ? `icons-tags/${this.targetSpaceId}/` : null;
     }
     /**
      * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL
@@ -14625,13 +15734,13 @@ class MatterportTagCopyService {
         // 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 ɵ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: HashtagService }, { token: SpaceService }, { 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 }] });
+        }], ctorParameters: () => [{ type: NavigationService }, { type: BaseUserService }, { type: PoiService }, { type: TicketsService }, { type: EquipmentService }, { type: Object3DService }, { type: FeatureService }, { type: MeasurementService }, { type: CommentService }, { type: HashtagService }, { type: SpaceService }, { type: i1.TranslateService }] });
 
 /* eslint-disable class-methods-use-this */
 class OrganisationService {
@@ -14840,5 +15949,5 @@ function floatValidator() {
  * Generated bundle index. Do not edit.
  */
 
-export { AffectationService, AvatarComponent, BaseLateralTabService, BaseTagService, BaseUserService, BaseVisibilityService, CameraMode, CaptureService, CaptureViewer, CommentService, CommentType, Config, ContentService, CsvExportComponent, DomainService, DomainType, DurationToStringPipe, EmailStatus, EquipmentService, EventService, EventStatus, EventType, FeatureService, FeatureType, FilterService, HashtagFromIdPipe, HashtagService, InterventionService, InventoryStatus, LayerService, LevelStatus, LoaderComponent, Locale, LocaleService, MATTERPORT_SDK_KEY, MatterportImportService, MatterportService, MatterportTagCopyService, 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 };
+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, applyRigidTransformToDirection, applyRigidTransformToPoint, applyRigidTransformToYRotationDeg, arraysContainSameElements, checkElementById, computeRigidTransform, convertTimestampToLocalZone, copyFileInS3, copyFileInS3ViaDownload, dateHasExpired, dateTimeToLocalString, deleteFromS3, distance, downloadBlob, downloadEquipmentDocument, downloadFile, downloadFileAsObject, durationToString, emailValidator, enumToArray, filterUniqueArrayByID, floatValidator, getBufferForFileFromS3, getCoefficientsForImage, getCurrentLang, getDistanceBetweenTwoPoints, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getLocaleLong, getLocaleShort, getMetaForImage, getRolesBelowForManager, getSignedFile, getSignedImageUrlForEquipment, getSignedImageUrlForProfile, getSignedImageUrlForSpace, getSpaceIDFromUrl, getVisitUrl, isEmptyObject, listFilesInFolder, mean, noEmptyValidator, numberToDateString, openDocument, openModalForVisitSwitch, 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