@smarterplan/ngx-smarterplan-core 1.4.11 → 1.4.13

package/esm2022/lib/services/matterport-tag-copy.service.mjs

@@ -0,0 +1,865 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { copyFileInS3 } from './s3.service'; // see s3.service.ts: copyFileInS3 must NOT swallow errors (needed to detect NoSuchKey below)
+import { computeRigidTransform, applyRigidTransformToPoint, applyRigidTransformToYRotationDeg } from './utils/matterport-transform.util';
+import { CommentType, PoiType, SpModule } from '../types.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./models/navigation.service";
+import * as i2 from "./user.service";
+import * as i3 from "./models/poi.service";
+import * as i4 from "./models/ticket.service";
+import * as i5 from "./models/equipment.service";
+import * as i6 from "./models/object3D.service";
+import * as i7 from "./models/feature.service";
+import * as i8 from "./models/measurement.service";
+import * as i9 from "./models/comment.service";
+import * as i10 from "@ngx-translate/core";
+/** Safely extracts a readable message from an unknown catch value, including Amplify's
+ *  GraphQL error shape ({ data, errors: [{ errorType, message }] }). */
+function toErrorMessage(err) {
+    if (err && typeof err === 'object') {
+        const anyErr = err;
+        if (Array.isArray(anyErr.errors) && anyErr.errors.length > 0) {
+            return anyErr.errors
+                .map((e) => {
+                const title = e.errorType ? `${e.errorType}: ` : '';
+                return `${title}${e.message || 'Unknown error'}`;
+            })
+                .join(' | ');
+        }
+        if (err instanceof Error) {
+            return err.message;
+        }
+    }
+    if (typeof err === 'string') {
+        return err;
+    }
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+/** Thrown when the referenced S3 source file doesn't exist (orphaned DB reference —
+ *  e.g. the file was deleted or renamed on S3 without updating the database).
+ *  Kept distinct from other copy failures so the calling loop can log a clear,
+ *  specific message and skip the whole item instead of a generic error. */
+class MissingS3FileError extends Error {
+    sourceKey;
+    contextLabel;
+    constructor(sourceKey, contextLabel) {
+        super(`Source file missing on S3: "${sourceKey}" (${contextLabel})`);
+        this.sourceKey = sourceKey;
+        this.contextLabel = contextLabel;
+        this.name = 'MissingS3FileError';
+    }
+}
+export class MatterportTagCopyService {
+    navigationService;
+    userService;
+    poiService;
+    ticketService;
+    equipmentService;
+    object3DService;
+    featureService;
+    measurementService;
+    commentService;
+    translate;
+    // Emits progress updates during copyTagsFromVisit(); null when idle
+    copyProgress$ = new BehaviorSubject(null);
+    // Emits the accumulated log lines during copyTagsFromVisit(); [] when idle
+    copyLog$ = new BehaviorSubject([]);
+    spModule;
+    log = [];
+    errorSeq = 0;
+    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, translate) {
+        this.navigationService = navigationService;
+        this.userService = userService;
+        this.poiService = poiService;
+        this.ticketService = ticketService;
+        this.equipmentService = equipmentService;
+        this.object3DService = object3DService;
+        this.featureService = featureService;
+        this.measurementService = measurementService;
+        this.commentService = commentService;
+        this.translate = translate;
+        this.spModule = userService.getSpModule();
+    }
+    //
+    // ---------- Public API ----------
+    //
+    async copyTagsFromVisit(sourceSpaceId, targetSpaceId, landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB) {
+        let errorCount = 0;
+        this.resetLog();
+        try {
+            console.log(`Copying Tags from source ${sourceSpaceId} to target ${targetSpaceId}`);
+            this.setStepProgress('collecting', 'collecting', 0);
+            this.copyProgress$.next({
+                phase: 'collecting',
+                processedInPhase: 0, totalInPhase: 0,
+                processedOverall: 0, totalOverall: 0,
+                percent: 0, errorCount: 0
+            });
+            const targetMission = this.userService.currentMission(targetSpaceId);
+            const targetMissionId = targetMission ? targetMission.id : null;
+            const transform = computeRigidTransform(landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB);
+            console.log('Rigid transform computed:', {
+                rotationYDeg: transform.rotationYRad * (180 / Math.PI),
+                refSource: transform.refSource,
+                refTarget: transform.refTarget
+            });
+            const sourceSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(sourceSpaceId);
+            const targetSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(targetSpaceId);
+            this.setStepProgress('collecting', 'collecting', 30);
+            const [sourceNavPositions, targetNavPositions] = await Promise.all([
+                this.buildNavigationPositionMap(sourceSpaceId, sourceSweepIds),
+                this.buildNavigationPositionMap(targetSpaceId, targetSweepIds)
+            ]);
+            const elementIds = {};
+            let sourceTickets = [];
+            let sourceEquipments = [];
+            let targetTickets = [];
+            let targetEquipments = [];
+            let sourceMeasurements = [];
+            let targetMeasurements = [];
+            if (this.spModule == SpModule.IMMO) {
+                sourceTickets = await this.ticketService.getTicketsBySpace(sourceSpaceId);
+                sourceEquipments = await this.equipmentService.getEquipmentsForSpace(sourceSpaceId);
+                targetTickets = await this.ticketService.getTicketsBySpace(targetSpaceId);
+                targetEquipments = await this.equipmentService.getEquipmentsForSpace(targetSpaceId);
+            }
+            this.setStepProgress('collecting', 'collecting', 55);
+            const sourceObjects3D = await this.object3DService.getObjects3DBySpace(sourceSpaceId);
+            const targetObjects3D = await this.object3DService.getObjects3DBySpace(targetSpaceId);
+            const sourceFeatures = await this.featureService.getFeaturesBySpaceWithoutFiltering(sourceSpaceId);
+            const targetFeatures = await this.featureService.getFeaturesBySpaceWithoutFiltering(targetSpaceId);
+            this.setStepProgress('collecting', 'collecting', 75);
+            if (this.spModule == SpModule.IMMO) {
+                sourceMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId);
+                targetMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId);
+            }
+            this.setStepProgress('collecting', 'collecting', 90);
+            const sourcePoisAll = await this.poiService.getPoisByMatterportSweeps(sourceSweepIds);
+            const targetPoisAll = await this.poiService.getPoisByMatterportSweeps(targetSweepIds);
+            const handledPoiTypes = new Set([
+                PoiType.TICKET, PoiType.EQUIPMENT, PoiType.DATA, PoiType.DESK,
+                PoiType.OBJECT3D, PoiType.MEASURE
+            ]);
+            const sourcePois = sourcePoisAll.filter(p => !handledPoiTypes.has(p.type));
+            const targetPois = targetPoisAll.filter(p => !handledPoiTypes.has(p.type));
+            this.setStepProgress('collecting', 'collecting', 100);
+            const totalOverall = sourceTickets.length + sourceEquipments.length + sourcePois.length
+                + sourceObjects3D.length + sourceFeatures.length + sourceMeasurements.length;
+            let processedOverall = 0;
+            const emitProgress = (phase, processedInPhase, totalInPhase) => {
+                this.copyProgress$.next({
+                    phase,
+                    processedInPhase,
+                    totalInPhase,
+                    processedOverall,
+                    totalOverall,
+                    percent: totalOverall > 0 ? Math.round((processedOverall / totalOverall) * 100) : 0,
+                    errorCount
+                });
+            };
+            if (this.spModule == SpModule.IMMO) {
+                // TICKETS
+                for (let i = 0; i < sourceTickets.length; i++) {
+                    const sourceObj = sourceTickets[i];
+                    try {
+                        const existsInTarget = this.matchesExisting(sourceObj, targetTickets);
+                        if (!existsInTarget) {
+                            const rawSource = sourceObj;
+                            const ticketInput = {
+                                title: rawSource.title,
+                                friendlyLabel: rawSource.friendlyLabel,
+                                status: rawSource.status,
+                                type: rawSource.type,
+                                priority: rawSource.priority,
+                                description: rawSource.description,
+                                level: rawSource.level,
+                                metadata: rawSource.metadata || null,
+                                read: rawSource.read || null,
+                                projectID: rawSource.projectID || null,
+                                problemCode: rawSource.problemCode || null,
+                                archivedForMissionID: rawSource.archivedForMissionID || null,
+                                spaceID: targetSpaceId,
+                                parentID: null,
+                                domainID: null,
+                                ownerMissionID: targetMissionId
+                            };
+                            const createdObj = await this.ticketService.createTicket(ticketInput);
+                            if (createdObj && createdObj.id) {
+                                elementIds[sourceObj.id] = createdObj.id;
+                            }
+                            if (sourceObj.pois.items && sourceObj.pois.items.length > 0) {
+                                const sourcePoi = sourceObj.pois.items[0];
+                                const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                                const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                                const poiInput = {
+                                    coordinate: JSON.stringify(adjustedCoordinate),
+                                    type: sourcePoi.type,
+                                    elementID: createdObj.id,
+                                    metadata: sourcePoi.metadata,
+                                    matterportSweepID: targetSweepId
+                                };
+                                await this.poiService.createPOIForSpaceID(poiInput);
+                            }
+                        }
+                    }
+                    catch (itemError) {
+                        console.error(`Error copying ticket "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
+                        errorCount++;
+                        this.logCopyItemError(itemError, 'errorTicket', sourceObj?.title || sourceObj?.id);
+                    }
+                    processedOverall++;
+                    emitProgress('tickets', i + 1, sourceTickets.length);
+                    const pct = sourceTickets.length > 0 ? Math.round(((i + 1) / sourceTickets.length) * 100) : 100;
+                    this.setStepProgress('tickets', 'tickets', pct);
+                }
+                // EQUIPMENTS (title, POI, PHOTO and NOTES/documents all copied — files physically
+                // duplicated in S3 first, so the copy stays independent from the source)
+                for (let i = 0; i < sourceEquipments.length; i++) {
+                    const sourceObj = sourceEquipments[i];
+                    try {
+                        const existsInTarget = this.matchesExisting(sourceObj, targetEquipments);
+                        if (!existsInTarget) {
+                            const rawSource = sourceObj;
+                            let copiedPhotoKey = null;
+                            if (rawSource.photo) {
+                                copiedPhotoKey = await this.copyS3KeyIfPresent(rawSource.photo, `equipment photo "${rawSource.title}"`);
+                            }
+                            const equipmentInput = {
+                                title: rawSource.title,
+                                status: rawSource.status,
+                                description: rawSource.description,
+                                archivedForMissionID: rawSource.archivedForMissionID || null,
+                                spaceID: targetSpaceId,
+                                domainID: null,
+                                photo: copiedPhotoKey,
+                            };
+                            const createdObj = await this.equipmentService.createEquipment(equipmentInput, null, null);
+                            if (createdObj && createdObj.id) {
+                                elementIds[sourceObj.id] = createdObj.id;
+                            }
+                            // Copy notes (documents, technical/financial/other/contractual/image notes)
+                            if (createdObj && rawSource.notes?.items && rawSource.notes.items.length > 0) {
+                                for (const sourceNote of rawSource.notes.items) {
+                                    try {
+                                        if (!sourceNote.attachment) {
+                                            continue; // nothing to duplicate for this note
+                                        }
+                                        const copiedKey = await this.copyS3KeyIfPresent(sourceNote.attachment, `equipment note for "${sourceObj?.title}"`);
+                                        await this.equipmentService.createNoteWithExistingAttachment(createdObj.id, copiedKey, sourceNote.type, targetMissionId);
+                                    }
+                                    catch (noteError) {
+                                        console.error(`Error copying note for equipment "${sourceObj?.title}":`, noteError);
+                                        errorCount++;
+                                        this.logCopyItemError(noteError, 'errorEquipmentNote', sourceObj?.title || sourceObj?.id);
+                                    }
+                                }
+                            }
+                            if (sourceObj.pois.items && sourceObj.pois.items.length > 0) {
+                                const sourcePoi = sourceObj.pois.items[0];
+                                const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                                const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                                const poiInput = {
+                                    coordinate: JSON.stringify(adjustedCoordinate),
+                                    type: sourcePoi.type,
+                                    elementID: createdObj.id,
+                                    metadata: sourcePoi.metadata,
+                                    matterportSweepID: targetSweepId
+                                };
+                                await this.poiService.createPOIForSpaceID(poiInput);
+                            }
+                        }
+                    }
+                    catch (itemError) {
+                        console.error(`Error copying equipment "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
+                        errorCount++;
+                        this.logCopyItemError(itemError, 'errorEquipment', sourceObj?.title || sourceObj?.id);
+                    }
+                    processedOverall++;
+                    emitProgress('equipments', i + 1, sourceEquipments.length);
+                    const pct = sourceEquipments.length > 0 ? Math.round(((i + 1) / sourceEquipments.length) * 100) : 100;
+                    this.setStepProgress('equipments', 'equipments', pct);
+                }
+                // Second pass: remap subequipmentsIDs on newly created equipments to point to
+                // their copied counterparts. IDs with no copied counterpart (source equipment
+                // wasn't copied — e.g. it already existed in target, or was skipped) are dropped
+                // rather than left dangling or pointing back at the source space's equipment.
+                for (const sourceObj of sourceEquipments) {
+                    const rawSource = sourceObj;
+                    const newId = elementIds[sourceObj.id];
+                    if (newId && rawSource.subequipmentsIDs && rawSource.subequipmentsIDs.length > 0) {
+                        const remapped = rawSource.subequipmentsIDs
+                            .map((subId) => elementIds[subId])
+                            .filter((id) => !!id);
+                        if (remapped.length > 0) {
+                            try {
+                                await this.equipmentService.updateEquipment({ id: newId, subequipmentsIDs: remapped });
+                            }
+                            catch (subEquipError) {
+                                console.error(`Error remapping sub-equipments for "${sourceObj?.title}":`, subEquipError);
+                                errorCount++;
+                                this.logCopyItemError(subEquipError, 'errorEquipmentSubEquip', sourceObj?.title || sourceObj?.id);
+                            }
+                        }
+                    }
+                }
+            }
+            // POIS (standalone — types already handled above are excluded)
+            for (let i = 0; i < sourcePois.length; i++) {
+                const sourcePoi = sourcePois[i];
+                try {
+                    const existsInTarget = targetPois.some(tp => tp.coordinate === sourcePoi.coordinate && tp.tagDescription === sourcePoi.tagDescription);
+                    if (!existsInTarget) {
+                        const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                        const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                        let elementID = sourcePoi.elementID;
+                        if (elementID && elementIds[elementID]) {
+                            elementID = elementIds[elementID];
+                        }
+                        const copiedTagIcon = await this.duplicateTagIcon(sourcePoi.tagIcon);
+                        const copiedTagImageID = await this.duplicateTagImageID(sourcePoi.tagImageID);
+                        const newPoi = {
+                            coordinate: JSON.stringify(adjustedCoordinate),
+                            type: sourcePoi.type,
+                            elementID: elementID,
+                            tagDescription: sourcePoi.tagDescription,
+                            tagIcon: copiedTagIcon,
+                            tagImageID: copiedTagImageID,
+                            virtual: sourcePoi.virtual,
+                            xRotation: sourcePoi.xRotation,
+                            yRotation: sourcePoi.yRotation,
+                            metadata: sourcePoi.metadata,
+                            matterportSweepID: targetSweepId
+                        };
+                        await this.poiService.createPOIForSpaceID(newPoi);
+                    }
+                }
+                catch (itemError) {
+                    console.error(`Error copying POI (sweep: ${sourcePoi?.matterportSweepID}):`, itemError);
+                    errorCount++;
+                    this.logCopyItemError(itemError, 'errorPoi', sourcePoi?.matterportSweepID);
+                }
+                processedOverall++;
+                emitProgress('pois', i + 1, sourcePois.length);
+                const pct = sourcePois.length > 0 ? Math.round(((i + 1) / sourcePois.length) * 100) : 100;
+                this.setStepProgress('pois', 'pois', pct);
+            }
+            // OBJECTS 3D (the 3D model file itself — `path` — is physically duplicated in S3)
+            for (let i = 0; i < sourceObjects3D.length; i++) {
+                const sourceObj = sourceObjects3D[i];
+                try {
+                    const existsInTarget = targetObjects3D.some(targetObj => targetObj.name === sourceObj.name);
+                    if (!existsInTarget) {
+                        const rawSource = sourceObj;
+                        let copiedPath = rawSource.path;
+                        if (rawSource.path) {
+                            copiedPath = await this.copyS3KeyIfPresent(rawSource.path, `3D object "${rawSource.name}"`);
+                        }
+                        /**
+                         * Strict parser to ensure [float, float, float] format for GraphQL.
+                         * Forces numbers, handles potential DynamoDB object structures,
+                         * and ensures we never send [0,0,0] for scale.
+                         */
+                        const toFloatArray = (val, defaultVal = [0, 0, 0]) => {
+                            let array = [];
+                            if (Array.isArray(val)) {
+                                // If DB format [ {N: "1"}, ... ]
+                                if (val.length > 0 && typeof val[0] === 'object' && 'N' in val[0]) {
+                                    array = val.map(item => parseFloat(item.N));
+                                }
+                                // If already standard array [1, 1, 1]
+                                else {
+                                    array = val.map(item => parseFloat(item));
+                                }
+                            }
+                            // If object {x, y, z}
+                            else if (val && typeof val === 'object') {
+                                array = [parseFloat(val.x), parseFloat(val.y), parseFloat(val.z)];
+                            }
+                            else {
+                                return defaultVal;
+                            }
+                            // Ensure we return valid numbers
+                            return array.map(n => isNaN(n) ? 0 : n);
+                        };
+                        const object3DInput = {
+                            path: copiedPath,
+                            name: rawSource.name,
+                            description: rawSource.description || "",
+                            viewFrustum: !!rawSource.viewFrustum,
+                            spaceID: targetSpaceId,
+                            position: toFloatArray(rawSource.position, [0, 0, 0]),
+                            rotation: toFloatArray(rawSource.rotation, [0, 0, 0]),
+                            // Enforce scale to be at least 1.0 if it's invalid
+                            scale: toFloatArray(rawSource.scale, [1, 1, 1])
+                        };
+                        // Debugging: Inspect the exact object sent to the mutation
+                        console.log(`[DEBUG] Sending Object3D "${rawSource.name}" to API:`, JSON.stringify(object3DInput));
+                        const createdObj = await this.object3DService.create(object3DInput);
+                        if (createdObj && createdObj.id) {
+                            elementIds[sourceObj.id] = createdObj.id;
+                        }
+                        if (sourceObj.pois?.items && sourceObj.pois.items.length > 0) {
+                            const sourcePoi = sourceObj.pois.items[0];
+                            const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                            const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                            const poiInput = {
+                                coordinate: JSON.stringify(adjustedCoordinate),
+                                type: sourcePoi.type,
+                                elementID: createdObj.id,
+                                metadata: sourcePoi.metadata,
+                                matterportSweepID: targetSweepId
+                            };
+                            await this.poiService.createPOIForSpaceID(poiInput);
+                        }
+                    }
+                }
+                catch (itemError) {
+                    console.error(`Error copying object3D "${sourceObj?.name}":`, itemError);
+                    errorCount++;
+                    this.logCopyItemError(itemError, 'errorObject3d', sourceObj?.name || sourceObj?.id);
+                }
+                processedOverall++;
+                emitProgress('objects3d', i + 1, sourceObjects3D.length);
+                const pct = sourceObjects3D.length > 0 ? Math.round(((i + 1) / sourceObjects3D.length) * 100) : 100;
+                this.setStepProgress('objects3d', 'objects3d', pct);
+            }
+            // FEATURES (title, POI, and attached comments — images/videos/docs/links — all copied,
+            // each file physically duplicated in S3 first)
+            for (let i = 0; i < sourceFeatures.length; i++) {
+                const sourceObj = sourceFeatures[i];
+                try {
+                    const existsInTarget = this.matchesExisting(sourceObj, targetFeatures);
+                    if (!existsInTarget) {
+                        const rawSource = sourceObj;
+                        const featureInput = {
+                            title: rawSource.title,
+                            shortDescription: rawSource.shortDescription,
+                            level: rawSource.level,
+                            type: rawSource.type,
+                            archivedForMissionID: rawSource.archivedForMissionID || null,
+                            stripeProductID: rawSource.stripeProductID || null,
+                            stripePriceID: rawSource.stripePriceID || null,
+                            bookingPriceMetadata: rawSource.bookingPriceMetadata || null,
+                            locale: rawSource.locale || null,
+                            hashtags: rawSource.hashtags || null,
+                            description: rawSource.description || null,
+                            domainID: null,
+                            spaceID: targetSpaceId,
+                            ownerMissionID: targetMissionId
+                        };
+                        const createdObj = await this.featureService.createFeature(featureInput);
+                        if (createdObj && createdObj.id) {
+                            elementIds[sourceObj.id] = createdObj.id;
+                        }
+                        if (createdObj && sourceObj.comments?.items && sourceObj.comments.items.length > 0) {
+                            for (const sourceComment of sourceObj.comments.items) {
+                                try {
+                                    const rawComment = sourceComment;
+                                    let copiedAnnexe = null;
+                                    if (rawComment.annexe) {
+                                        copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `feature attachment "${rawComment.title}"`);
+                                    }
+                                    const commentInput = {
+                                        title: rawComment.title,
+                                        type: rawComment.type,
+                                        annexe: copiedAnnexe,
+                                        externalLink: rawComment.externalLink || null,
+                                        dimensions: rawComment.dimensions || null,
+                                        index: rawComment.index,
+                                        shownInTag: rawComment.shownInTag,
+                                        isCoverImage: rawComment.isCoverImage,
+                                        featureID: createdObj.id,
+                                        spaceID: targetSpaceId,
+                                        ownerID: targetMissionId
+                                    };
+                                    await this.commentService.createComment(commentInput);
+                                }
+                                catch (attachmentError) {
+                                    console.error(`Error copying attachment "${sourceComment?.title}" for feature "${sourceObj?.title}":`, attachmentError);
+                                    errorCount++;
+                                    this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || sourceComment?.id);
+                                }
+                            }
+                        }
+                        if (sourceObj.pois?.items && sourceObj.pois.items.length > 0) {
+                            const sourcePoi = sourceObj.pois.items[0];
+                            const targetSweepId = this.findClosestTargetSweepId(sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                            const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);
+                            const poiInput = {
+                                coordinate: JSON.stringify(adjustedCoordinate),
+                                type: sourcePoi.type,
+                                elementID: createdObj.id,
+                                metadata: sourcePoi.metadata,
+                                matterportSweepID: targetSweepId
+                            };
+                            await this.poiService.createPOIForSpaceID(poiInput);
+                        }
+                    }
+                }
+                catch (itemError) {
+                    console.error(`Error copying feature "${sourceObj?.title}" (id: ${sourceObj?.id}):`, itemError);
+                    errorCount++;
+                    this.logCopyItemError(itemError, 'errorFeature', sourceObj?.title || sourceObj?.id);
+                }
+                processedOverall++;
+                emitProgress('features', i + 1, sourceFeatures.length);
+                const pct = sourceFeatures.length > 0 ? Math.round(((i + 1) / sourceFeatures.length) * 100) : 100;
+                this.setStepProgress('features', 'features', pct);
+            }
+            // MEASUREMENTS (IMMO only — a Comment + a positional-only POI, no rotation;
+            // the screenshot file is physically duplicated in S3 first)
+            if (this.spModule == SpModule.IMMO) {
+                for (let i = 0; i < sourceMeasurements.length; i++) {
+                    const sourceMeasurement = sourceMeasurements[i];
+                    try {
+                        const existsInTarget = targetMeasurements.some(tm => tm.comment.title === sourceMeasurement.comment.title);
+                        if (!existsInTarget) {
+                            const rawComment = sourceMeasurement.comment;
+                            let copiedAnnexe = null;
+                            if (rawComment.annexe) {
+                                copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `measurement screenshot "${rawComment.title}"`);
+                            }
+                            const commentInput = {
+                                title: rawComment.title,
+                                type: CommentType.MEASURE,
+                                dimensions: rawComment.dimensions || null,
+                                annexe: copiedAnnexe,
+                                spaceID: targetSpaceId,
+                            };
+                            const createdComment = await this.commentService.createComment(commentInput);
+                            if (createdComment && sourceMeasurement.poi) {
+                                const targetSweepId = this.findClosestTargetSweepId(sourceMeasurement.poi.matterportSweepID, sourceNavPositions, targetNavPositions, transform);
+                                const adjustedPosition = this.getAdjustedPositionOnly(sourceMeasurement.poi.coordinate, transform);
+                                const poiInput = {
+                                    coordinate: JSON.stringify(adjustedPosition),
+                                    type: PoiType.MEASURE,
+                                    elementID: createdComment.id,
+                                    metadata: sourceMeasurement.poi.metadata,
+                                    matterportSweepID: targetSweepId
+                                };
+                                await this.poiService.createPOIForSpaceID(poiInput);
+                            }
+                        }
+                    }
+                    catch (itemError) {
+                        console.error(`Error copying measurement "${sourceMeasurement?.comment?.title}":`, itemError);
+                        errorCount++;
+                        this.logCopyItemError(itemError, 'errorMeasurement', sourceMeasurement?.comment?.title || sourceMeasurement?.id);
+                    }
+                    processedOverall++;
+                    emitProgress('measurements', i + 1, sourceMeasurements.length);
+                    const pct = sourceMeasurements.length > 0 ? Math.round(((i + 1) / sourceMeasurements.length) * 100) : 100;
+                    this.setStepProgress('measurements', 'measurements', pct);
+                }
+            }
+            this.copyProgress$.next({
+                phase: 'done',
+                processedInPhase: 0, totalInPhase: 0,
+                processedOverall, totalOverall,
+                percent: 100, errorCount
+            });
+            this.setStepLog('done', errorCount > 0
+                ? this.translate.instant('matterportCopy.doneWithErrors', { count: errorCount })
+                : this.translate.instant('matterportCopy.done'));
+            return true;
+        }
+        catch (error) {
+            console.error('Error copying POIs:', error);
+            this.appendErrorLog(this.translate.instant('matterportCopy.errorGeneral', { error: toErrorMessage(error) }));
+            this.copyProgress$.next(null);
+            return false;
+        }
+    }
+    //
+    // ---------- Progress / log helpers ----------
+    //
+    /** Adds or updates a step line (identified by stepId) with new text, then republishes the log. */
+    setStepLog(stepId, text) {
+        const existingIndex = this.log.findIndex(e => e.type === 'step' && e.id === stepId);
+        const entry = { id: stepId, type: 'step', text };
+        if (existingIndex >= 0) {
+            this.log[existingIndex] = entry;
+        }
+        else {
+            this.log.push(entry);
+        }
+        this.copyLog$.next([...this.log]);
+    }
+    /** Appends a new, permanent log line (never overwritten), then republishes the log. */
+    appendErrorLog(text) {
+        this.errorSeq++;
+        this.log.push({ id: `error-${this.errorSeq}`, type: 'error', text });
+        this.copyLog$.next([...this.log]);
+    }
+    /** Resets the log for a new run. */
+    resetLog() {
+        this.log = [];
+        this.errorSeq = 0;
+        this.copyLog$.next([]);
+    }
+    /** Builds and sets a step's log line as "<translated label>: <percent>%", no step numbering. */
+    setStepProgress(stepId, translationKey, percent) {
+        const label = this.translate.instant(`matterportCopy.${translationKey}`);
+        this.setStepLog(stepId, `${label}: ${percent}%`);
+    }
+    /** Logs a translated, parameterized error line for a single failed item. */
+    logItemError(translationKey, params) {
+        const text = this.translate.instant(`matterportCopy.${translationKey}`, params);
+        this.appendErrorLog(text);
+    }
+    /** Logs an item-level error, using a specific "missing file / orphaned reference"
+     *  translation key when the cause is a MissingS3FileError, and the generic per-type
+     *  key otherwise. Keeps the copy log readable: a missing file is not a bug to
+     *  investigate the same way a network/permission error is. */
+    logCopyItemError(error, genericKey, itemLabel) {
+        if (error instanceof MissingS3FileError) {
+            this.logItemError('errorMissingS3FileSkipped', {
+                name: itemLabel,
+                file: error.sourceKey
+            });
+        }
+        else {
+            this.logItemError(genericKey, { name: itemLabel, error: toErrorMessage(error) });
+        }
+    }
+    //
+    // ---------- Duplicate detection ----------
+    //
+    /**
+     * Heuristic duplicate-detection: compares title AND description together instead of
+     * title alone, to reduce false positives when several source items happen to share
+     * the same title. Not a perfect guarantee, but meaningfully more robust.
+     */
+    matchesExisting(source, targetList) {
+        return targetList.some(t => t.title === source.title && (t.description || null) === (source.description || null));
+    }
+    //
+    // ---------- Sweep positions / rigid transform ----------
+    //
+    /**
+     * Fetches the position of every sweep in a space and returns it as a Map for O(1) lookup.
+     * Uses allSettled so a single failing sweep lookup doesn't abort the whole map —
+     * that sweep is simply absent from the resulting map (and skipped later).
+     */
+    async buildNavigationPositionMap(spaceId, sweepIds) {
+        const map = new Map();
+        const results = await Promise.allSettled(sweepIds.map(async (sid) => {
+            const navs = await this.navigationService.getNavigationsForMatterportIDForSpace(sid, spaceId);
+            if (navs && navs.length > 0 && navs[0].position) {
+                return { sid, position: JSON.parse(navs[0].position) };
+            }
+            return null;
+        }));
+        for (const result of results) {
+            if (result.status === 'fulfilled' && result.value) {
+                map.set(result.value.sid, result.value.position);
+            }
+            else if (result.status === 'rejected') {
+                console.warn('Failed to fetch a sweep position, skipping it:', result.reason);
+            }
+        }
+        return map;
+    }
+    /** Applies the rigid transform to a POI coordinate (position + orientation). */
+    getAdjustedCoordinates(coordinate, transform) {
+        if (coordinate === "null") {
+            return null;
+        }
+        if (!coordinate || typeof coordinate !== 'string') {
+            return coordinate;
+        }
+        const parsed = JSON.parse(coordinate);
+        const rotatedPos = applyRigidTransformToPoint({ x: parsed.x, y: parsed.y, z: parsed.z }, transform);
+        return {
+            x: rotatedPos.x,
+            y: rotatedPos.y,
+            z: rotatedPos.z,
+            xRotation: parsed.xRotation,
+            yRotation: applyRigidTransformToYRotationDeg(parsed.yRotation, transform)
+        };
+    }
+    /**
+     * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,
+     * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored
+     * coordinate is a bare position (no orientation), unlike other POI types.
+     */
+    getAdjustedPositionOnly(coordinate, transform) {
+        if (!coordinate || typeof coordinate !== 'string' || coordinate === 'null') {
+            return coordinate;
+        }
+        const parsed = JSON.parse(coordinate);
+        return applyRigidTransformToPoint({ x: parsed.x, y: parsed.y, z: parsed.z }, transform);
+    }
+    /**
+     * Finds the closest target sweep, comparing positions in the SAME coordinate frame.
+     * Pure in-memory lookup — no network call, thanks to the pre-built position maps.
+     */
+    findClosestTargetSweepId(sourceSweepID, sourceNavPositions, targetNavPositions, transform) {
+        if (!sourceSweepID)
+            return null;
+        const sourcePos = sourceNavPositions.get(sourceSweepID);
+        if (!sourcePos)
+            return null;
+        const sourcePosInTargetFrame = applyRigidTransformToPoint(sourcePos, transform);
+        let closestSweepID = null;
+        let minDistance = Infinity;
+        for (const [targetSweepId, targetPos] of targetNavPositions.entries()) {
+            const dx = targetPos.x - sourcePosInTargetFrame.x;
+            const dy = targetPos.y - sourcePosInTargetFrame.y;
+            const dz = targetPos.z - sourcePosInTargetFrame.z;
+            const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+            if (dist < minDistance) {
+                minDistance = dist;
+                closestSweepID = targetSweepId;
+            }
+        }
+        return closestSweepID;
+    }
+    //
+    // ---------- S3 file duplication ----------
+    //
+    /** Generates a short random id, used to give each copied S3 file a fresh, collision-safe key. */
+    generateShortId() {
+        return Math.random().toString(36).slice(2, 10);
+    }
+    /**
+     * Builds a new S3 key for a copied attachment and sanitizes the filename
+     * to prevent AWS Amplify SignatureDoesNotMatch errors.
+     */
+    buildCopiedAttachmentKey(sourceAnnexe) {
+        const lastSlash = sourceAnnexe.lastIndexOf('/');
+        const folder = sourceAnnexe.substring(0, lastSlash + 1);
+        let filename = sourceAnnexe.substring(lastSlash + 1);
+        // Strip a leading "<8 hex chars>_" id prefix if present
+        const prefixMatch = filename.match(/^[0-9a-fA-F-]{8}_(.+)$/);
+        if (prefixMatch) {
+            filename = prefixMatch[1];
+        }
+        // SANITIZATION: Replace spaces, parentheses, and accents with underscores
+        // Crucial to prevent Amplify's Storage.copy from failing the signature calculation
+        filename = filename.replace(/[^a-zA-Z0-9.\-_]/g, '_');
+        const newPrefix = `${this.generateShortId()}_`;
+        return `${folder}${newPrefix}${filename}`;
+    }
+    /**
+     * Duplicates an S3 object if a key is present.
+     * - If the source file is genuinely missing from S3 (NoSuchKey / orphaned DB reference),
+     *   throws a MissingS3FileError so the caller can log a clear, specific message and
+     *   skip the whole item entirely, rather than creating a record with a broken file link.
+     * - Any other kind of failure (permissions, network, etc.) still throws a generic Error.
+     */
+    async copyS3KeyIfPresent(key, contextLabel) {
+        if (!key) {
+            return null;
+        }
+        const sourceKey = this.extractS3KeyFromValue(key);
+        const destKey = this.buildCopiedAttachmentKey(sourceKey);
+        // Log the source key to ensure it matches the real S3 object path
+        console.log(`[DEBUG] Attempting S3 copy from source: "${sourceKey}" to dest: "${destKey}"`);
+        try {
+            const copied = await copyFileInS3(sourceKey, destKey);
+            if (!copied) {
+                throw new MissingS3FileError(sourceKey, contextLabel);
+            }
+            return copied;
+        }
+        catch (error) {
+            const isMissingFile = error instanceof MissingS3FileError
+                || error?.code === 'NoSuchKey'
+                || /NoSuchKey|does not exist/i.test(toErrorMessage(error));
+            if (isMissingFile) {
+                console.warn(`[MatterportTagCopyService] Orphaned S3 reference, skipping item: "${sourceKey}" (${contextLabel})`);
+                throw new MissingS3FileError(sourceKey, contextLabel);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Duplicates the file referenced by a POI's tagIcon (a JSON string shaped like
+     * { src, opacity }, per form-feature.component.ts). If the JSON can't be parsed or
+     * has no `src`, the value is returned unchanged rather than risk corrupting it.
+     */
+    async duplicateTagIcon(tagIconRaw) {
+        if (!tagIconRaw) {
+            return tagIconRaw;
+        }
+        try {
+            const parsed = JSON.parse(tagIconRaw);
+            if (parsed && parsed.src) {
+                parsed.src = await this.copyS3KeyIfPresent(parsed.src, 'tag icon');
+            }
+            return JSON.stringify(parsed);
+        }
+        catch {
+            // Not JSON, or unexpected shape — leave untouched rather than guess.
+            return tagIconRaw;
+        }
+    }
+    /**
+     * Duplicates tagImageID if it looks like a reference to a file (contains a path
+     * separator, whether raw key or pre-signed URL). UNCONFIRMED ASSUMPTION: this
+     * field's exact semantics weren't verified — if it's actually an opaque reference
+     * to another DB record rather than a file, this heuristic may incorrectly attempt
+     * a copy. Confirm the real structure to tighten this if it causes issues.
+     */
+    async duplicateTagImageID(tagImageID) {
+        if (!tagImageID || !tagImageID.includes('/')) {
+            return tagImageID;
+        }
+        return this.copyS3KeyIfPresent(tagImageID, 'tag image');
+    }
+    /**
+     * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL
+     * or already a raw key).
+     * IMPORTANT: this must return the RAW (decoded, non URL-encoded) key. Amplify's
+     * Storage.copy() already builds and encodes the 'x-amz-copy-source' header internally
+     * from the key we give it. Pre-encoding it here caused a double-encoding bug (e.g. a
+     * space became "%2520" instead of "%20"), so Storage.copy() looked for a key that never
+     * existed on S3, resulting in a NoSuchKey error.
+     */
+    extractS3KeyFromValue(value) {
+        if (!value) {
+            return '';
+        }
+        let extracted = value;
+        // 1. Extract path from URL and drop query params
+        if (value.startsWith('http://') || value.startsWith('https://')) {
+            try {
+                const url = new URL(value);
+                extracted = decodeURIComponent(url.pathname);
+            }
+            catch {
+                extracted = value.split('?')[0];
+            }
+        }
+        else {
+            extracted = value.split('?')[0];
+        }
+        // 2. Remove leading slash
+        if (extracted.startsWith('/')) {
+            extracted = extracted.substring(1);
+        }
+        // 3. Remove 'public/' prefix
+        // Amplify prepends this automatically; we must strip it from the input
+        // to avoid the 'public/public/' double-prefix issue.
+        if (extracted.startsWith('public/')) {
+            extracted = extracted.substring('public/'.length);
+        }
+        // Return the raw key as-is — Storage.copy() takes care of properly encoding it
+        // for the CopySource header. Do NOT re-encode it here.
+        return extracted;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, deps: [{ token: i1.NavigationService }, { token: i2.BaseUserService }, { token: i3.PoiService }, { token: i4.TicketsService }, { token: i5.EquipmentService }, { token: i6.Object3DService }, { token: i7.FeatureService }, { token: i8.MeasurementService }, { token: i9.CommentService }, { token: i10.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: i1.NavigationService }, { type: i2.BaseUserService }, { type: i3.PoiService }, { type: i4.TicketsService }, { type: i5.EquipmentService }, { type: i6.Object3DService }, { type: i7.FeatureService }, { type: i8.MeasurementService }, { type: i9.CommentService }, { type: i10.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matterport-tag-copy.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/matterport-tag-copy.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { POI } from '../types.service';\r\nimport { NavigationService } from './models/navigation.service';\r\nimport { PoiService } from './models/poi.service';\r\nimport { TicketsService } from './models/ticket.service';\r\nimport { EquipmentService } from './models/equipment.service';\r\nimport { Object3DService } from './models/object3D.service';\r\nimport { FeatureService } from './models/feature.service';\r\nimport { MeasurementService } from './models/measurement.service';\r\nimport { CommentService } from './models/comment.service';\r\nimport { BaseUserService } from './user.service';\r\nimport { copyFileInS3 } from './s3.service'; // see s3.service.ts: copyFileInS3 must NOT swallow errors (needed to detect NoSuchKey below)\r\nimport {\r\n    computeRigidTransform, applyRigidTransformToPoint,\r\n    applyRigidTransformToYRotationDeg, RigidTransform, Vec3\r\n} from './utils/matterport-transform.util';\r\nimport { Object3D, Feature, Measurement, Comment, CommentType, PoiType, Equipment, SpModule, Ticket } from '../types.service';\r\n\r\n/** Progress snapshot emitted during copyTagsFromVisit(), so the UI can show a live status. */\r\nexport interface CopyProgress {\r\n    phase: 'collecting' | 'tickets' | 'equipments' | 'pois' | 'objects3d' | 'features' | 'measurements' | 'done';\r\n    processedInPhase: number;\r\n    totalInPhase: number;\r\n    processedOverall: number;\r\n    totalOverall: number;\r\n    percent: number;\r\n    errorCount: number;\r\n}\r\n\r\n/** A single line in the copy log — either a step status (updated in place) or an error (appended once). */\r\nexport interface CopyLogEntry {\r\n    id: string;       // stable id for step lines (so they update in place), unique for error lines\r\n    type: 'step' | 'error';\r\n    text: string;\r\n}\r\n\r\n/** Safely extracts a readable message from an unknown catch value, including Amplify's\r\n *  GraphQL error shape ({ data, errors: [{ errorType, message }] }). */\r\nfunction toErrorMessage(err: unknown): string {\r\n    if (err && typeof err === 'object') {\r\n        const anyErr = err as any;\r\n        if (Array.isArray(anyErr.errors) && anyErr.errors.length > 0) {\r\n            return anyErr.errors\r\n                .map((e: any) => {\r\n                    const title = e.errorType ? `${e.errorType}: ` : '';\r\n                    return `${title}${e.message || 'Unknown error'}`;\r\n                })\r\n                .join(' | ');\r\n        }\r\n        if (err instanceof Error) {\r\n            return err.message;\r\n        }\r\n    }\r\n    if (typeof err === 'string') {\r\n        return err;\r\n    }\r\n    try {\r\n        return JSON.stringify(err);\r\n    } catch {\r\n        return String(err);\r\n    }\r\n}\r\n\r\n/** Thrown when the referenced S3 source file doesn't exist (orphaned DB reference —\r\n *  e.g. the file was deleted or renamed on S3 without updating the database).\r\n *  Kept distinct from other copy failures so the calling loop can log a clear,\r\n *  specific message and skip the whole item instead of a generic error. */\r\nclass MissingS3FileError extends Error {\r\n    constructor(public readonly sourceKey: string, public readonly contextLabel: string) {\r\n        super(`Source file missing on S3: \"${sourceKey}\" (${contextLabel})`);\r\n        this.name = 'MissingS3FileError';\r\n    }\r\n}\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class MatterportTagCopyService {\r\n\r\n    // Emits progress updates during copyTagsFromVisit(); null when idle\r\n    public copyProgress$: BehaviorSubject<CopyProgress | null> = new BehaviorSubject<CopyProgress | null>(null);\r\n\r\n    // Emits the accumulated log lines during copyTagsFromVisit(); [] when idle\r\n    public copyLog$: BehaviorSubject<CopyLogEntry[]> = new BehaviorSubject<CopyLogEntry[]>([]);\r\n\r\n    private spModule: SpModule;\r\n    private log: CopyLogEntry[] = [];\r\n    private errorSeq = 0;\r\n\r\n    constructor(\r\n        private navigationService: NavigationService,\r\n        private userService: BaseUserService,\r\n        private poiService: PoiService,\r\n        private ticketService: TicketsService,\r\n        private equipmentService: EquipmentService,\r\n        private object3DService: Object3DService,\r\n        private featureService: FeatureService,\r\n        private measurementService: MeasurementService,\r\n        private commentService: CommentService,\r\n        private translate: TranslateService\r\n    ) {\r\n        this.spModule = userService.getSpModule();\r\n    }\r\n\r\n    //\r\n    // ---------- Public API ----------\r\n    //\r\n\r\n    async copyTagsFromVisit(\r\n        sourceSpaceId: string,\r\n        targetSpaceId: string,\r\n        landmarkSourceA: Vec3, landmarkTargetA: Vec3,\r\n        landmarkSourceB: Vec3, landmarkTargetB: Vec3\r\n    ): Promise<boolean> {\r\n        let errorCount = 0;\r\n        this.resetLog();\r\n\r\n        try {\r\n            console.log(`Copying Tags from source ${sourceSpaceId} to target ${targetSpaceId}`);\r\n\r\n            this.setStepProgress('collecting', 'collecting', 0);\r\n            this.copyProgress$.next({\r\n                phase: 'collecting',\r\n                processedInPhase: 0, totalInPhase: 0,\r\n                processedOverall: 0, totalOverall: 0,\r\n                percent: 0, errorCount: 0\r\n            });\r\n\r\n            const targetMission = this.userService.currentMission(targetSpaceId);\r\n            const targetMissionId = targetMission ? targetMission.id : null;\r\n\r\n            const transform: RigidTransform = computeRigidTransform(\r\n                landmarkSourceA, landmarkTargetA,\r\n                landmarkSourceB, landmarkTargetB\r\n            );\r\n            console.log('Rigid transform computed:', {\r\n                rotationYDeg: transform.rotationYRad * (180 / Math.PI),\r\n                refSource: transform.refSource,\r\n                refTarget: transform.refTarget\r\n            });\r\n\r\n            const sourceSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(sourceSpaceId);\r\n            const targetSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(targetSpaceId);\r\n\r\n            this.setStepProgress('collecting', 'collecting', 30);\r\n\r\n            const [sourceNavPositions, targetNavPositions] = await Promise.all([\r\n                this.buildNavigationPositionMap(sourceSpaceId, sourceSweepIds),\r\n                this.buildNavigationPositionMap(targetSpaceId, targetSweepIds)\r\n            ]);\r\n\r\n            const elementIds: Record<string, string> = {};\r\n\r\n            let sourceTickets: Ticket[] = [];\r\n            let sourceEquipments: Equipment[] = [];\r\n            let targetTickets: Ticket[] = [];\r\n            let targetEquipments: Equipment[] = [];\r\n            let sourceMeasurements: Measurement[] = [];\r\n            let targetMeasurements: Measurement[] = [];\r\n\r\n            if (this.spModule == SpModule.IMMO) {\r\n                sourceTickets = await this.ticketService.getTicketsBySpace(sourceSpaceId);\r\n                sourceEquipments = await this.equipmentService.getEquipmentsForSpace(sourceSpaceId);\r\n                targetTickets = await this.ticketService.getTicketsBySpace(targetSpaceId);\r\n                targetEquipments = await this.equipmentService.getEquipmentsForSpace(targetSpaceId);\r\n            }\r\n\r\n            this.setStepProgress('collecting', 'collecting', 55);\r\n\r\n            const sourceObjects3D = await this.object3DService.getObjects3DBySpace(sourceSpaceId);\r\n            const targetObjects3D = await this.object3DService.getObjects3DBySpace(targetSpaceId);\r\n\r\n            const sourceFeatures = await this.featureService.getFeaturesBySpaceWithoutFiltering(sourceSpaceId);\r\n            const targetFeatures = await this.featureService.getFeaturesBySpaceWithoutFiltering(targetSpaceId);\r\n\r\n            this.setStepProgress('collecting', 'collecting', 75);\r\n\r\n            if (this.spModule == SpModule.IMMO) {\r\n                sourceMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId);\r\n                targetMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId);\r\n            }\r\n\r\n            this.setStepProgress('collecting', 'collecting', 90);\r\n\r\n            const sourcePoisAll = await this.poiService.getPoisByMatterportSweeps(sourceSweepIds);\r\n            const targetPoisAll = await this.poiService.getPoisByMatterportSweeps(targetSweepIds);\r\n\r\n            const handledPoiTypes = new Set<string>([\r\n                PoiType.TICKET, PoiType.EQUIPMENT, PoiType.DATA, PoiType.DESK,\r\n                PoiType.OBJECT3D, PoiType.MEASURE\r\n            ]);\r\n            const sourcePois = sourcePoisAll.filter(p => !handledPoiTypes.has(p.type as string));\r\n            const targetPois = targetPoisAll.filter(p => !handledPoiTypes.has(p.type as string));\r\n\r\n            this.setStepProgress('collecting', 'collecting', 100);\r\n\r\n            const totalOverall = sourceTickets.length + sourceEquipments.length + sourcePois.length\r\n                + sourceObjects3D.length + sourceFeatures.length + sourceMeasurements.length;\r\n            let processedOverall = 0;\r\n\r\n            const emitProgress = (phase: CopyProgress['phase'], processedInPhase: number, totalInPhase: number) => {\r\n                this.copyProgress$.next({\r\n                    phase,\r\n                    processedInPhase,\r\n                    totalInPhase,\r\n                    processedOverall,\r\n                    totalOverall,\r\n                    percent: totalOverall > 0 ? Math.round((processedOverall / totalOverall) * 100) : 0,\r\n                    errorCount\r\n                });\r\n            };\r\n\r\n            if (this.spModule == SpModule.IMMO) {\r\n                // TICKETS\r\n                for (let i = 0; i < sourceTickets.length; i++) {\r\n                    const sourceObj = sourceTickets[i];\r\n\r\n                    try {\r\n                        const existsInTarget = this.matchesExisting(sourceObj as any, targetTickets as any);\r\n\r\n                        if (!existsInTarget) {\r\n                            const rawSource = sourceObj as any;\r\n\r\n                            const ticketInput: any = {\r\n                                title: rawSource.title,\r\n                                friendlyLabel: rawSource.friendlyLabel,\r\n                                status: rawSource.status,\r\n                                type: rawSource.type,\r\n                                priority: rawSource.priority,\r\n                                description: rawSource.description,\r\n                                level: rawSource.level,\r\n                                metadata: rawSource.metadata || null,\r\n                                read: rawSource.read || null,\r\n                                projectID: rawSource.projectID || null,\r\n                                problemCode: rawSource.problemCode || null,\r\n                                archivedForMissionID: rawSource.archivedForMissionID || null,\r\n                                spaceID: targetSpaceId,\r\n                                parentID: null,\r\n                                domainID: null,\r\n                                ownerMissionID: targetMissionId\r\n                            };\r\n\r\n                            const createdObj = await this.ticketService.createTicket(ticketInput);\r\n\r\n                            if (createdObj && createdObj.id) {\r\n                                elementIds[sourceObj.id] = createdObj.id;\r\n                            }\r\n\r\n                            if (sourceObj.pois.items && sourceObj.pois.items.length > 0) {\r\n                                const sourcePoi = sourceObj.pois.items[0];\r\n                                const targetSweepId = this.findClosestTargetSweepId(\r\n                                    sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\r\n                                );\r\n                                const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);\r\n                                const poiInput: POI = {\r\n                                    coordinate: JSON.stringify(adjustedCoordinate),\r\n                                    type: sourcePoi.type,\r\n                                    elementID: createdObj.id,\r\n                                    metadata: sourcePoi.metadata,\r\n                                    matterportSweepID: targetSweepId\r\n                                };\r\n                                await this.poiService.createPOIForSpaceID(poiInput);\r\n                            }\r\n                        }\r\n                    } catch (itemError) {\r\n                        console.error(`Error copying ticket \"${sourceObj?.title}\" (id: ${sourceObj?.id}):`, itemError);\r\n                        errorCount++;\r\n                        this.logCopyItemError(itemError, 'errorTicket', sourceObj?.title || sourceObj?.id);\r\n                    }\r\n\r\n                    processedOverall++;\r\n                    emitProgress('tickets', i + 1, sourceTickets.length);\r\n                    const pct = sourceTickets.length > 0 ? Math.round(((i + 1) / sourceTickets.length) * 100) : 100;\r\n                    this.setStepProgress('tickets', 'tickets', pct);\r\n                }\r\n\r\n                // EQUIPMENTS (title, POI, PHOTO and NOTES/documents all copied — files physically\r\n                // duplicated in S3 first, so the copy stays independent from the source)\r\n                for (let i = 0; i < sourceEquipments.length; i++) {\r\n                    const sourceObj = sourceEquipments[i];\r\n\r\n                    try {\r\n                        const existsInTarget = this.matchesExisting(sourceObj as any, targetEquipments as any);\r\n\r\n                        if (!existsInTarget) {\r\n                            const rawSource = sourceObj as any;\r\n\r\n                            let copiedPhotoKey: string | null = null;\r\n                            if (rawSource.photo) {\r\n                                copiedPhotoKey = await this.copyS3KeyIfPresent(rawSource.photo, `equipment photo \"${rawSource.title}\"`);\r\n                            }\r\n\r\n                            const equipmentInput: any = {\r\n                                title: rawSource.title,\r\n                                status: rawSource.status,\r\n                                description: rawSource.description,\r\n                                archivedForMissionID: rawSource.archivedForMissionID || null,\r\n                                spaceID: targetSpaceId,\r\n                                domainID: null,\r\n                                photo: copiedPhotoKey,\r\n                            };\r\n\r\n                            const createdObj: any = await this.equipmentService.createEquipment(equipmentInput, null, null);\r\n\r\n                            if (createdObj && createdObj.id) {\r\n                                elementIds[sourceObj.id] = createdObj.id;\r\n                            }\r\n\r\n                            // Copy notes (documents, technical/financial/other/contractual/image notes)\r\n                            if (createdObj && rawSource.notes?.items && rawSource.notes.items.length > 0) {\r\n                                for (const sourceNote of rawSource.notes.items) {\r\n                                    try {\r\n                                        if (!sourceNote.attachment) {\r\n                                            continue; // nothing to duplicate for this note\r\n                                        }\r\n                                        const copiedKey = await this.copyS3KeyIfPresent(sourceNote.attachment, `equipment note for \"${sourceObj?.title}\"`);\r\n                                        await this.equipmentService.createNoteWithExistingAttachment(\r\n                                            createdObj.id, copiedKey, sourceNote.type, targetMissionId\r\n                                        );\r\n                                    } catch (noteError) {\r\n                                        console.error(`Error copying note for equipment \"${sourceObj?.title}\":`, noteError);\r\n                                        errorCount++;\r\n                                        this.logCopyItemError(noteError, 'errorEquipmentNote', sourceObj?.title || sourceObj?.id);\r\n                                    }\r\n                                }\r\n                            }\r\n\r\n                            if (sourceObj.pois.items && sourceObj.pois.items.length > 0) {\r\n                                const sourcePoi = sourceObj.pois.items[0];\r\n                                const targetSweepId = this.findClosestTargetSweepId(\r\n                                    sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\r\n                                );\r\n                                const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);\r\n                                const poiInput: POI = {\r\n                                    coordinate: JSON.stringify(adjustedCoordinate),\r\n                                    type: sourcePoi.type,\r\n                                    elementID: createdObj.id,\r\n                                    metadata: sourcePoi.metadata,\r\n                                    matterportSweepID: targetSweepId\r\n                                };\r\n                                await this.poiService.createPOIForSpaceID(poiInput);\r\n                            }\r\n                        }\r\n                    } catch (itemError) {\r\n                        console.error(`Error copying equipment \"${sourceObj?.title}\" (id: ${sourceObj?.id}):`, itemError);\r\n                        errorCount++;\r\n                        this.logCopyItemError(itemError, 'errorEquipment', sourceObj?.title || sourceObj?.id);\r\n                    }\r\n\r\n                    processedOverall++;\r\n                    emitProgress('equipments', i + 1, sourceEquipments.length);\r\n                    const pct = sourceEquipments.length > 0 ? Math.round(((i + 1) / sourceEquipments.length) * 100) : 100;\r\n                    this.setStepProgress('equipments', 'equipments', pct);\r\n                }\r\n\r\n                // Second pass: remap subequipmentsIDs on newly created equipments to point to\r\n                // their copied counterparts. IDs with no copied counterpart (source equipment\r\n                // wasn't copied — e.g. it already existed in target, or was skipped) are dropped\r\n                // rather than left dangling or pointing back at the source space's equipment.\r\n                for (const sourceObj of sourceEquipments) {\r\n                    const rawSource = sourceObj as any;\r\n                    const newId = elementIds[sourceObj.id];\r\n                    if (newId && rawSource.subequipmentsIDs && rawSource.subequipmentsIDs.length > 0) {\r\n                        const remapped = rawSource.subequipmentsIDs\r\n                            .map((subId: string) => elementIds[subId])\r\n                            .filter((id: string | undefined) => !!id);\r\n\r\n                        if (remapped.length > 0) {\r\n                            try {\r\n                                await this.equipmentService.updateEquipment({ id: newId, subequipmentsIDs: remapped });\r\n                            } catch (subEquipError) {\r\n                                console.error(`Error remapping sub-equipments for \"${sourceObj?.title}\":`, subEquipError);\r\n                                errorCount++;\r\n                                this.logCopyItemError(subEquipError, 'errorEquipmentSubEquip', sourceObj?.title || sourceObj?.id);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            // POIS (standalone — types already handled above are excluded)\r\n            for (let i = 0; i < sourcePois.length; i++) {\r\n                const sourcePoi = sourcePois[i];\r\n\r\n                try {\r\n                    const existsInTarget = targetPois.some(\r\n                        tp => tp.coordinate === sourcePoi.coordinate && tp.tagDescription === sourcePoi.tagDescription\r\n                    );\r\n\r\n                    if (!existsInTarget) {\r\n                        const targetSweepId = this.findClosestTargetSweepId(\r\n                            sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\r\n                        );\r\n                        const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);\r\n\r\n                        let elementID = sourcePoi.elementID;\r\n                        if (elementID && elementIds[elementID]) {\r\n                            elementID = elementIds[elementID];\r\n                        }\r\n\r\n                        const copiedTagIcon = await this.duplicateTagIcon(sourcePoi.tagIcon);\r\n                        const copiedTagImageID = await this.duplicateTagImageID(sourcePoi.tagImageID);\r\n\r\n                        const newPoi: POI = {\r\n                            coordinate: JSON.stringify(adjustedCoordinate),\r\n                            type: sourcePoi.type,\r\n                            elementID: elementID,\r\n                            tagDescription: sourcePoi.tagDescription,\r\n                            tagIcon: copiedTagIcon,\r\n                            tagImageID: copiedTagImageID,\r\n                            virtual: sourcePoi.virtual,\r\n                            xRotation: sourcePoi.xRotation,\r\n                            yRotation: sourcePoi.yRotation,\r\n                            metadata: sourcePoi.metadata,\r\n                            matterportSweepID: targetSweepId\r\n                        };\r\n                        await this.poiService.createPOIForSpaceID(newPoi);\r\n                    }\r\n                } catch (itemError) {\r\n                    console.error(`Error copying POI (sweep: ${sourcePoi?.matterportSweepID}):`, itemError);\r\n                    errorCount++;\r\n                    this.logCopyItemError(itemError, 'errorPoi', sourcePoi?.matterportSweepID);\r\n                }\r\n\r\n                processedOverall++;\r\n                emitProgress('pois', i + 1, sourcePois.length);\r\n                const pct = sourcePois.length > 0 ? Math.round(((i + 1) / sourcePois.length) * 100) : 100;\r\n                this.setStepProgress('pois', 'pois', pct);\r\n            }\r\n\r\n            // OBJECTS 3D (the 3D model file itself — `path` — is physically duplicated in S3)\r\n            for (let i = 0; i < sourceObjects3D.length; i++) {\r\n                const sourceObj = sourceObjects3D[i];\r\n\r\n                try {\r\n                    const existsInTarget = targetObjects3D.some(targetObj => targetObj.name === sourceObj.name);\r\n\r\n                    if (!existsInTarget) {\r\n                        const rawSource = sourceObj as any;\r\n\r\n                        let copiedPath = rawSource.path;\r\n                        if (rawSource.path) {\r\n                            copiedPath = await this.copyS3KeyIfPresent(rawSource.path, `3D object \"${rawSource.name}\"`);\r\n                        }\r\n\r\n                        /**\r\n                         * Strict parser to ensure [float, float, float] format for GraphQL.\r\n                         * Forces numbers, handles potential DynamoDB object structures,\r\n                         * and ensures we never send [0,0,0] for scale.\r\n                         */\r\n                        const toFloatArray = (val: any, defaultVal: number[] = [0, 0, 0]): number[] => {\r\n                            let array: number[] = [];\r\n\r\n                            if (Array.isArray(val)) {\r\n                                // If DB format [ {N: \"1\"}, ... ]\r\n                                if (val.length > 0 && typeof val[0] === 'object' && 'N' in val[0]) {\r\n                                    array = val.map(item => parseFloat(item.N));\r\n                                }\r\n                                // If already standard array [1, 1, 1]\r\n                                else {\r\n                                    array = val.map(item => parseFloat(item));\r\n                                }\r\n                            }\r\n                            // If object {x, y, z}\r\n                            else if (val && typeof val === 'object') {\r\n                                array = [parseFloat(val.x), parseFloat(val.y), parseFloat(val.z)];\r\n                            } else {\r\n                                return defaultVal;\r\n                            }\r\n\r\n                            // Ensure we return valid numbers\r\n                            return array.map(n => isNaN(n) ? 0 : n);\r\n                        };\r\n\r\n                        const object3DInput: any = {\r\n                            path: copiedPath,\r\n                            name: rawSource.name,\r\n                            description: rawSource.description || \"\",\r\n                            viewFrustum: !!rawSource.viewFrustum,\r\n                            spaceID: targetSpaceId,\r\n                            position: toFloatArray(rawSource.position, [0, 0, 0]),\r\n                            rotation: toFloatArray(rawSource.rotation, [0, 0, 0]),\r\n                            // Enforce scale to be at least 1.0 if it's invalid\r\n                            scale: toFloatArray(rawSource.scale, [1, 1, 1])\r\n                        };\r\n\r\n                        // Debugging: Inspect the exact object sent to the mutation\r\n                        console.log(`[DEBUG] Sending Object3D \"${rawSource.name}\" to API:`, JSON.stringify(object3DInput));\r\n\r\n                        const createdObj = await this.object3DService.create(object3DInput);\r\n\r\n                        if (createdObj && createdObj.id) {\r\n                            elementIds[sourceObj.id] = createdObj.id;\r\n                        }\r\n\r\n                        if (sourceObj.pois?.items && sourceObj.pois.items.length > 0) {\r\n                            const sourcePoi = sourceObj.pois.items[0];\r\n                            const targetSweepId = this.findClosestTargetSweepId(\r\n                                sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\r\n                            );\r\n                            const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);\r\n                            const poiInput: POI = {\r\n                                coordinate: JSON.stringify(adjustedCoordinate),\r\n                                type: sourcePoi.type,\r\n                                elementID: createdObj.id,\r\n                                metadata: sourcePoi.metadata,\r\n                                matterportSweepID: targetSweepId\r\n                            };\r\n                            await this.poiService.createPOIForSpaceID(poiInput);\r\n                        }\r\n                    }\r\n                } catch (itemError) {\r\n                    console.error(`Error copying object3D \"${sourceObj?.name}\":`, itemError);\r\n                    errorCount++;\r\n                    this.logCopyItemError(itemError, 'errorObject3d', sourceObj?.name || sourceObj?.id);\r\n                }\r\n\r\n                processedOverall++;\r\n                emitProgress('objects3d', i + 1, sourceObjects3D.length);\r\n                const pct = sourceObjects3D.length > 0 ? Math.round(((i + 1) / sourceObjects3D.length) * 100) : 100;\r\n                this.setStepProgress('objects3d', 'objects3d', pct);\r\n            }\r\n\r\n            // FEATURES (title, POI, and attached comments — images/videos/docs/links — all copied,\r\n            // each file physically duplicated in S3 first)\r\n            for (let i = 0; i < sourceFeatures.length; i++) {\r\n                const sourceObj = sourceFeatures[i];\r\n\r\n                try {\r\n                    const existsInTarget = this.matchesExisting(sourceObj as any, targetFeatures as any);\r\n\r\n                    if (!existsInTarget) {\r\n                        const rawSource = sourceObj as any;\r\n\r\n                        const featureInput: any = {\r\n                            title: rawSource.title,\r\n                            shortDescription: rawSource.shortDescription,\r\n                            level: rawSource.level,\r\n                            type: rawSource.type,\r\n                            archivedForMissionID: rawSource.archivedForMissionID || null,\r\n                            stripeProductID: rawSource.stripeProductID || null,\r\n                            stripePriceID: rawSource.stripePriceID || null,\r\n                            bookingPriceMetadata: rawSource.bookingPriceMetadata || null,\r\n                            locale: rawSource.locale || null,\r\n                            hashtags: rawSource.hashtags || null,\r\n                            description: rawSource.description || null,\r\n                            domainID: null,\r\n                            spaceID: targetSpaceId,\r\n                            ownerMissionID: targetMissionId\r\n                        };\r\n\r\n                        const createdObj = await this.featureService.createFeature(featureInput);\r\n\r\n                        if (createdObj && createdObj.id) {\r\n                            elementIds[sourceObj.id] = createdObj.id;\r\n                        }\r\n\r\n                        if (createdObj && sourceObj.comments?.items && sourceObj.comments.items.length > 0) {\r\n                            for (const sourceComment of sourceObj.comments.items) {\r\n                                try {\r\n                                    const rawComment = sourceComment as any;\r\n\r\n                                    let copiedAnnexe: string | null = null;\r\n                                    if (rawComment.annexe) {\r\n                                        copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `feature attachment \"${rawComment.title}\"`);\r\n                                    }\r\n\r\n                                    const commentInput: any = {\r\n                                        title: rawComment.title,\r\n                                        type: rawComment.type,\r\n                                        annexe: copiedAnnexe,\r\n                                        externalLink: rawComment.externalLink || null,\r\n                                        dimensions: rawComment.dimensions || null,\r\n                                        index: rawComment.index,\r\n                                        shownInTag: rawComment.shownInTag,\r\n                                        isCoverImage: rawComment.isCoverImage,\r\n                                        featureID: createdObj.id,\r\n                                        spaceID: targetSpaceId,\r\n                                        ownerID: targetMissionId\r\n                                    };\r\n\r\n                                    await this.commentService.createComment(commentInput);\r\n                                } catch (attachmentError) {\r\n                                    console.error(`Error copying attachment \"${sourceComment?.title}\" for feature \"${sourceObj?.title}\":`, attachmentError);\r\n                                    errorCount++;\r\n                                    this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || sourceComment?.id);\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (sourceObj.pois?.items && sourceObj.pois.items.length > 0) {\r\n                            const sourcePoi = sourceObj.pois.items[0];\r\n                            const targetSweepId = this.findClosestTargetSweepId(\r\n                                sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\r\n                            );\r\n                            const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);\r\n                            const poiInput: POI = {\r\n                                coordinate: JSON.stringify(adjustedCoordinate),\r\n                                type: sourcePoi.type,\r\n                                elementID: createdObj.id,\r\n                                metadata: sourcePoi.metadata,\r\n                                matterportSweepID: targetSweepId\r\n                            };\r\n                            await this.poiService.createPOIForSpaceID(poiInput);\r\n                        }\r\n                    }\r\n                } catch (itemError) {\r\n                    console.error(`Error copying feature \"${sourceObj?.title}\" (id: ${sourceObj?.id}):`, itemError);\r\n                    errorCount++;\r\n                    this.logCopyItemError(itemError, 'errorFeature', sourceObj?.title || sourceObj?.id);\r\n                }\r\n\r\n                processedOverall++;\r\n                emitProgress('features', i + 1, sourceFeatures.length);\r\n                const pct = sourceFeatures.length > 0 ? Math.round(((i + 1) / sourceFeatures.length) * 100) : 100;\r\n                this.setStepProgress('features', 'features', pct);\r\n            }\r\n\r\n            // MEASUREMENTS (IMMO only — a Comment + a positional-only POI, no rotation;\r\n            // the screenshot file is physically duplicated in S3 first)\r\n            if (this.spModule == SpModule.IMMO) {\r\n                for (let i = 0; i < sourceMeasurements.length; i++) {\r\n                    const sourceMeasurement = sourceMeasurements[i];\r\n\r\n                    try {\r\n                        const existsInTarget = targetMeasurements.some(\r\n                            tm => tm.comment.title === sourceMeasurement.comment.title\r\n                        );\r\n\r\n                        if (!existsInTarget) {\r\n                            const rawComment = sourceMeasurement.comment as any;\r\n\r\n                            let copiedAnnexe: string | null = null;\r\n                            if (rawComment.annexe) {\r\n                                copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `measurement screenshot \"${rawComment.title}\"`);\r\n                            }\r\n\r\n                            const commentInput: any = {\r\n                                title: rawComment.title,\r\n                                type: CommentType.MEASURE,\r\n                                dimensions: rawComment.dimensions || null,\r\n                                annexe: copiedAnnexe,\r\n                                spaceID: targetSpaceId,\r\n                            };\r\n\r\n                            const createdComment: Comment = await this.commentService.createComment(commentInput);\r\n\r\n                            if (createdComment && sourceMeasurement.poi) {\r\n                                const targetSweepId = this.findClosestTargetSweepId(\r\n                                    sourceMeasurement.poi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\r\n                                );\r\n                                const adjustedPosition = this.getAdjustedPositionOnly(sourceMeasurement.poi.coordinate, transform);\r\n                                const poiInput: POI = {\r\n                                    coordinate: JSON.stringify(adjustedPosition),\r\n                                    type: PoiType.MEASURE,\r\n                                    elementID: (createdComment as any).id,\r\n                                    metadata: sourceMeasurement.poi.metadata,\r\n                                    matterportSweepID: targetSweepId\r\n                                };\r\n                                await this.poiService.createPOIForSpaceID(poiInput);\r\n                            }\r\n                        }\r\n                    } catch (itemError) {\r\n                        console.error(`Error copying measurement \"${sourceMeasurement?.comment?.title}\":`, itemError);\r\n                        errorCount++;\r\n                        this.logCopyItemError(itemError, 'errorMeasurement', sourceMeasurement?.comment?.title || sourceMeasurement?.id);\r\n                    }\r\n\r\n                    processedOverall++;\r\n                    emitProgress('measurements', i + 1, sourceMeasurements.length);\r\n                    const pct = sourceMeasurements.length > 0 ? Math.round(((i + 1) / sourceMeasurements.length) * 100) : 100;\r\n                    this.setStepProgress('measurements', 'measurements', pct);\r\n                }\r\n            }\r\n\r\n            this.copyProgress$.next({\r\n                phase: 'done',\r\n                processedInPhase: 0, totalInPhase: 0,\r\n                processedOverall, totalOverall,\r\n                percent: 100, errorCount\r\n            });\r\n            this.setStepLog('done', errorCount > 0\r\n                ? this.translate.instant('matterportCopy.doneWithErrors', { count: errorCount })\r\n                : this.translate.instant('matterportCopy.done'));\r\n\r\n            return true;\r\n        } catch (error) {\r\n            console.error('Error copying POIs:', error);\r\n            this.appendErrorLog(this.translate.instant('matterportCopy.errorGeneral', { error: toErrorMessage(error) }));\r\n            this.copyProgress$.next(null);\r\n            return false;\r\n        }\r\n    }\r\n\r\n    //\r\n    // ---------- Progress / log helpers ----------\r\n    //\r\n\r\n    /** Adds or updates a step line (identified by stepId) with new text, then republishes the log. */\r\n    private setStepLog(stepId: string, text: string) {\r\n        const existingIndex = this.log.findIndex(e => e.type === 'step' && e.id === stepId);\r\n        const entry: CopyLogEntry = { id: stepId, type: 'step', text };\r\n        if (existingIndex >= 0) {\r\n            this.log[existingIndex] = entry;\r\n        } else {\r\n            this.log.push(entry);\r\n        }\r\n        this.copyLog$.next([...this.log]);\r\n    }\r\n\r\n    /** Appends a new, permanent log line (never overwritten), then republishes the log. */\r\n    private appendErrorLog(text: string) {\r\n        this.errorSeq++;\r\n        this.log.push({ id: `error-${this.errorSeq}`, type: 'error', text });\r\n        this.copyLog$.next([...this.log]);\r\n    }\r\n\r\n    /** Resets the log for a new run. */\r\n    private resetLog() {\r\n        this.log = [];\r\n        this.errorSeq = 0;\r\n        this.copyLog$.next([]);\r\n    }\r\n\r\n    /** Builds and sets a step's log line as \"<translated label>: <percent>%\", no step numbering. */\r\n    private setStepProgress(stepId: string, translationKey: string, percent: number) {\r\n        const label = this.translate.instant(`matterportCopy.${translationKey}`);\r\n        this.setStepLog(stepId, `${label}: ${percent}%`);\r\n    }\r\n\r\n    /** Logs a translated, parameterized error line for a single failed item. */\r\n    private logItemError(translationKey: string, params: Record<string, any>) {\r\n        const text = this.translate.instant(`matterportCopy.${translationKey}`, params);\r\n        this.appendErrorLog(text);\r\n    }\r\n\r\n    /** Logs an item-level error, using a specific \"missing file / orphaned reference\"\r\n     *  translation key when the cause is a MissingS3FileError, and the generic per-type\r\n     *  key otherwise. Keeps the copy log readable: a missing file is not a bug to\r\n     *  investigate the same way a network/permission error is. */\r\n    private logCopyItemError(error: unknown, genericKey: string, itemLabel: string) {\r\n        if (error instanceof MissingS3FileError) {\r\n            this.logItemError('errorMissingS3FileSkipped', {\r\n                name: itemLabel,\r\n                file: error.sourceKey\r\n            });\r\n        } else {\r\n            this.logItemError(genericKey, { name: itemLabel, error: toErrorMessage(error) });\r\n        }\r\n    }\r\n\r\n    //\r\n    // ---------- Duplicate detection ----------\r\n    //\r\n\r\n    /**\r\n     * Heuristic duplicate-detection: compares title AND description together instead of\r\n     * title alone, to reduce false positives when several source items happen to share\r\n     * the same title. Not a perfect guarantee, but meaningfully more robust.\r\n     */\r\n    private matchesExisting<T extends { title?: string; description?: string }>(source: T, targetList: T[]): boolean {\r\n        return targetList.some(t =>\r\n            t.title === source.title && (t.description || null) === (source.description || null)\r\n        );\r\n    }\r\n\r\n    //\r\n    // ---------- Sweep positions / rigid transform ----------\r\n    //\r\n\r\n    /**\r\n     * Fetches the position of every sweep in a space and returns it as a Map for O(1) lookup.\r\n     * Uses allSettled so a single failing sweep lookup doesn't abort the whole map —\r\n     * that sweep is simply absent from the resulting map (and skipped later).\r\n     */\r\n    private async buildNavigationPositionMap(spaceId: string, sweepIds: string[]): Promise<Map<string, Vec3>> {\r\n        const map = new Map<string, Vec3>();\r\n\r\n        const results = await Promise.allSettled(\r\n            sweepIds.map(async (sid) => {\r\n                const navs = await this.navigationService.getNavigationsForMatterportIDForSpace(sid, spaceId);\r\n                if (navs && navs.length > 0 && navs[0].position) {\r\n                    return { sid, position: JSON.parse(navs[0].position) as Vec3 };\r\n                }\r\n                return null;\r\n            })\r\n        );\r\n\r\n        for (const result of results) {\r\n            if (result.status === 'fulfilled' && result.value) {\r\n                map.set(result.value.sid, result.value.position);\r\n            } else if (result.status === 'rejected') {\r\n                console.warn('Failed to fetch a sweep position, skipping it:', result.reason);\r\n            }\r\n        }\r\n\r\n        return map;\r\n    }\r\n\r\n    /** Applies the rigid transform to a POI coordinate (position + orientation). */\r\n    private getAdjustedCoordinates(coordinate: string, transform: RigidTransform): any {\r\n        if (coordinate === \"null\") {\r\n            return null;\r\n        }\r\n        if (!coordinate || typeof coordinate !== 'string') {\r\n            return coordinate;\r\n        }\r\n\r\n        const parsed = JSON.parse(coordinate);\r\n        const rotatedPos = applyRigidTransformToPoint(\r\n            { x: parsed.x, y: parsed.y, z: parsed.z },\r\n            transform\r\n        );\r\n\r\n        return {\r\n            x: rotatedPos.x,\r\n            y: rotatedPos.y,\r\n            z: rotatedPos.z,\r\n            xRotation: parsed.xRotation,\r\n            yRotation: applyRigidTransformToYRotationDeg(parsed.yRotation, transform)\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,\r\n     * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored\r\n     * coordinate is a bare position (no orientation), unlike other POI types.\r\n     */\r\n    private getAdjustedPositionOnly(coordinate: string, transform: RigidTransform): any {\r\n        if (!coordinate || typeof coordinate !== 'string' || coordinate === 'null') {\r\n            return coordinate;\r\n        }\r\n        const parsed = JSON.parse(coordinate);\r\n        return applyRigidTransformToPoint({ x: parsed.x, y: parsed.y, z: parsed.z }, transform);\r\n    }\r\n\r\n    /**\r\n     * Finds the closest target sweep, comparing positions in the SAME coordinate frame.\r\n     * Pure in-memory lookup — no network call, thanks to the pre-built position maps.\r\n     */\r\n    private findClosestTargetSweepId(\r\n        sourceSweepID: string,\r\n        sourceNavPositions: Map<string, Vec3>,\r\n        targetNavPositions: Map<string, Vec3>,\r\n        transform: RigidTransform\r\n    ): string | null {\r\n        if (!sourceSweepID) return null;\r\n\r\n        const sourcePos = sourceNavPositions.get(sourceSweepID);\r\n        if (!sourcePos) return null;\r\n\r\n        const sourcePosInTargetFrame = applyRigidTransformToPoint(sourcePos, transform);\r\n\r\n        let closestSweepID: string | null = null;\r\n        let minDistance = Infinity;\r\n\r\n        for (const [targetSweepId, targetPos] of targetNavPositions.entries()) {\r\n            const dx = targetPos.x - sourcePosInTargetFrame.x;\r\n            const dy = targetPos.y - sourcePosInTargetFrame.y;\r\n            const dz = targetPos.z - sourcePosInTargetFrame.z;\r\n            const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);\r\n\r\n            if (dist < minDistance) {\r\n                minDistance = dist;\r\n                closestSweepID = targetSweepId;\r\n            }\r\n        }\r\n\r\n        return closestSweepID;\r\n    }\r\n\r\n    //\r\n    // ---------- S3 file duplication ----------\r\n    //\r\n\r\n    /** Generates a short random id, used to give each copied S3 file a fresh, collision-safe key. */\r\n    private generateShortId(): string {\r\n        return Math.random().toString(36).slice(2, 10);\r\n    }\r\n\r\n    /**\r\n     * Builds a new S3 key for a copied attachment and sanitizes the filename\r\n     * to prevent AWS Amplify SignatureDoesNotMatch errors.\r\n     */\r\n    private buildCopiedAttachmentKey(sourceAnnexe: string): string {\r\n        const lastSlash = sourceAnnexe.lastIndexOf('/');\r\n        const folder = sourceAnnexe.substring(0, lastSlash + 1);\r\n        let filename = sourceAnnexe.substring(lastSlash + 1);\r\n\r\n        // Strip a leading \"<8 hex chars>_\" id prefix if present\r\n        const prefixMatch = filename.match(/^[0-9a-fA-F-]{8}_(.+)$/);\r\n        if (prefixMatch) {\r\n            filename = prefixMatch[1];\r\n        }\r\n\r\n        // SANITIZATION: Replace spaces, parentheses, and accents with underscores\r\n        // Crucial to prevent Amplify's Storage.copy from failing the signature calculation\r\n        filename = filename.replace(/[^a-zA-Z0-9.\\-_]/g, '_');\r\n\r\n        const newPrefix = `${this.generateShortId()}_`;\r\n        return `${folder}${newPrefix}${filename}`;\r\n    }\r\n\r\n    /**\r\n     * Duplicates an S3 object if a key is present.\r\n     * - If the source file is genuinely missing from S3 (NoSuchKey / orphaned DB reference),\r\n     *   throws a MissingS3FileError so the caller can log a clear, specific message and\r\n     *   skip the whole item entirely, rather than creating a record with a broken file link.\r\n     * - Any other kind of failure (permissions, network, etc.) still throws a generic Error.\r\n     */\r\n    private async copyS3KeyIfPresent(key: string | null | undefined, contextLabel: string): Promise<string | null> {\r\n        if (!key) {\r\n            return null;\r\n        }\r\n        const sourceKey = this.extractS3KeyFromValue(key);\r\n        const destKey = this.buildCopiedAttachmentKey(sourceKey);\r\n\r\n        // Log the source key to ensure it matches the real S3 object path\r\n        console.log(`[DEBUG] Attempting S3 copy from source: \"${sourceKey}\" to dest: \"${destKey}\"`);\r\n\r\n        try {\r\n            const copied = await copyFileInS3(sourceKey, destKey);\r\n            if (!copied) {\r\n                throw new MissingS3FileError(sourceKey, contextLabel);\r\n            }\r\n            return copied;\r\n        } catch (error: any) {\r\n            const isMissingFile = error instanceof MissingS3FileError\r\n                || error?.code === 'NoSuchKey'\r\n                || /NoSuchKey|does not exist/i.test(toErrorMessage(error));\r\n            if (isMissingFile) {\r\n                console.warn(`[MatterportTagCopyService] Orphaned S3 reference, skipping item: \"${sourceKey}\" (${contextLabel})`);\r\n                throw new MissingS3FileError(sourceKey, contextLabel);\r\n            }\r\n            throw error;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Duplicates the file referenced by a POI's tagIcon (a JSON string shaped like\r\n     * { src, opacity }, per form-feature.component.ts). If the JSON can't be parsed or\r\n     * has no `src`, the value is returned unchanged rather than risk corrupting it.\r\n     */\r\n    private async duplicateTagIcon(tagIconRaw: string | null | undefined): Promise<string | null | undefined> {\r\n        if (!tagIconRaw) {\r\n            return tagIconRaw;\r\n        }\r\n        try {\r\n            const parsed = JSON.parse(tagIconRaw);\r\n            if (parsed && parsed.src) {\r\n                parsed.src = await this.copyS3KeyIfPresent(parsed.src, 'tag icon');\r\n            }\r\n            return JSON.stringify(parsed);\r\n        } catch {\r\n            // Not JSON, or unexpected shape — leave untouched rather than guess.\r\n            return tagIconRaw;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Duplicates tagImageID if it looks like a reference to a file (contains a path\r\n     * separator, whether raw key or pre-signed URL). UNCONFIRMED ASSUMPTION: this\r\n     * field's exact semantics weren't verified — if it's actually an opaque reference\r\n     * to another DB record rather than a file, this heuristic may incorrectly attempt\r\n     * a copy. Confirm the real structure to tighten this if it causes issues.\r\n     */\r\n    private async duplicateTagImageID(tagImageID: string | null | undefined): Promise<string | null | undefined> {\r\n        if (!tagImageID || !tagImageID.includes('/')) {\r\n            return tagImageID;\r\n        }\r\n        return this.copyS3KeyIfPresent(tagImageID, 'tag image');\r\n    }\r\n\r\n    /**\r\n     * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL\r\n     * or already a raw key).\r\n     * IMPORTANT: this must return the RAW (decoded, non URL-encoded) key. Amplify's\r\n     * Storage.copy() already builds and encodes the 'x-amz-copy-source' header internally\r\n     * from the key we give it. Pre-encoding it here caused a double-encoding bug (e.g. a\r\n     * space became \"%2520\" instead of \"%20\"), so Storage.copy() looked for a key that never\r\n     * existed on S3, resulting in a NoSuchKey error.\r\n     */\r\n    private extractS3KeyFromValue(value: string): string {\r\n        if (!value) {\r\n            return '';\r\n        }\r\n\r\n        let extracted = value;\r\n\r\n        // 1. Extract path from URL and drop query params\r\n        if (value.startsWith('http://') || value.startsWith('https://')) {\r\n            try {\r\n                const url = new URL(value);\r\n                extracted = decodeURIComponent(url.pathname);\r\n            } catch {\r\n                extracted = value.split('?')[0];\r\n            }\r\n        } else {\r\n            extracted = value.split('?')[0];\r\n        }\r\n\r\n        // 2. Remove leading slash\r\n        if (extracted.startsWith('/')) {\r\n            extracted = extracted.substring(1);\r\n        }\r\n\r\n        // 3. Remove 'public/' prefix\r\n        // Amplify prepends this automatically; we must strip it from the input\r\n        // to avoid the 'public/public/' double-prefix issue.\r\n        if (extracted.startsWith('public/')) {\r\n            extracted = extracted.substring('public/'.length);\r\n        }\r\n\r\n        // Return the raw key as-is — Storage.copy() takes care of properly encoding it\r\n        // for the CopySource header. Do NOT re-encode it here.\r\n        return extracted;\r\n    }\r\n}"]}