@smarterplan/ngx-smarterplan-core 1.4.16 → 1.4.18

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

@@ -1,8 +1,9 @@
 import { Injectable } from '@angular/core';
 import { BehaviorSubject } from 'rxjs';
-import { copyFileInS3, copyFileInS3ViaDownload } from './s3.service'; // see s3.service.ts: neither must swallow errors (needed to detect NoSuchKey / signature mismatch below)
+import { copyFileInS3, copyFileInS3ViaDownload, getSignedFile } from './s3.service'; // see s3.service.ts: neither must swallow errors (needed to detect NoSuchKey / signature mismatch below)
 import { downloadBlob } from '../helpers.service';
-import { computeRigidTransform, applyRigidTransformToPoint, applyRigidTransformToDirection, applyRigidTransformToYRotationDeg } from './utils/matterport-transform.util';
+import { API, graphqlOperation } from 'aws-amplify';
+import { computeRigidTransform, applyRigidTransformToPoint, applyRigidTransformToDirection, distance, 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";
@@ -19,6 +20,7 @@ import * as i11 from "./models/mission.service";
 import * as i12 from "./models/operation.service";
 import * as i13 from "./models/domain.service";
 import * as i14 from "@ngx-translate/core";
+import * as i15 from "./models/zone.service";
 /** Safely extracts a readable message from an unknown catch value, including Amplify's
  *  GraphQL error shape ({ data, errors: [{ errorType, message }] }). */
 function toErrorMessage(err) {
@@ -75,6 +77,7 @@ export class MatterportTagCopyService {
     operationService;
     domainService;
     translate;
+    zoneService;
     // Emits progress updates during copyTagsFromVisit(); null when idle
     copyProgress$ = new BehaviorSubject(null);
     // Emits the accumulated log lines during copyTagsFromVisit(); [] when idle
@@ -134,7 +137,7 @@ export class MatterportTagCopyService {
     targetDomainIdsByTypeAndName = new Map();
     /** Target space id of the run in progress — used to re-home copied tag icons. */
     targetSpaceId = null;
-    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, hashtagService, missionService, operationService, domainService, translate) {
+    constructor(navigationService, userService, poiService, ticketService, equipmentService, object3DService, featureService, measurementService, commentService, hashtagService, missionService, operationService, domainService, translate, zoneService) {
         this.navigationService = navigationService;
         this.userService = userService;
         this.poiService = poiService;
@@ -149,6 +152,7 @@ export class MatterportTagCopyService {
         this.operationService = operationService;
         this.domainService = domainService;
         this.translate = translate;
+        this.zoneService = zoneService;
         this.spModule = userService.getSpModule();
     }
     //
@@ -157,6 +161,8 @@ export class MatterportTagCopyService {
     async copyTagsFromVisit(sourceSpaceId, targetSpaceId, landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB) {
         let errorCount = 0;
         let healedCount = 0;
+        // items skipped because an equivalent already exists in the target (earlier run)
+        let alreadyPresentCount = 0;
         this.resetLog();
         this.resetRunState(targetSpaceId);
         try {
@@ -225,8 +231,9 @@ export class MatterportTagCopyService {
             // loadDomainIndex() for why this is keyed to Mission, not to the Space itself.
             await this.loadDomainIndex(sourceSpaceId, targetSpaceId);
             if (this.spModule == SpModule.IMMO) {
-                sourceMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId);
-                targetMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId);
+                sourceMeasurements = (await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId))
+                    .filter(m => (m.numberPoints ?? 0) > 0);
+                targetMeasurements = (await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId));
             }
             this.setStepProgress('collecting', 'collecting', 90);
             const sourcePoisAll = await this.poiService.getPoisByMatterportSweeps(sourceSweepIds);
@@ -290,6 +297,9 @@ export class MatterportTagCopyService {
                     const sourceObj = sourceTickets[i];
                     try {
                         const existingMatch = this.findExisting(sourceObj, targetTickets, (t) => [t.title, t.description]);
+                        if (existingMatch) {
+                            alreadyPresentCount++;
+                        }
                         if (!existingMatch) {
                             const rawSource = sourceObj;
                             const ticketInput = {
@@ -409,6 +419,9 @@ export class MatterportTagCopyService {
                         // Equipment has no `title`/`description`: it identifies itself by name, and by
                         // serial number when one is recorded.
                         const existingMatch = this.findExisting(sourceObj, targetEquipments, (e) => [e.name, e.serialNumber]);
+                        if (existingMatch) {
+                            alreadyPresentCount++;
+                        }
                         if (!existingMatch) {
                             const rawSource = sourceObj;
                             let copiedPhotoKey = null;
@@ -588,6 +601,9 @@ export class MatterportTagCopyService {
                 const sourceObj = sourceObjects3D[i];
                 try {
                     const existsInTarget = targetObjects3D.some(targetObj => targetObj.name === sourceObj.name);
+                    if (existsInTarget) {
+                        alreadyPresentCount++;
+                    }
                     if (!existsInTarget) {
                         const rawSource = sourceObj;
                         // `path` means two different things depending on `s3Bucket`, exactly as the
@@ -705,6 +721,9 @@ export class MatterportTagCopyService {
                 const sourceObj = sourceFeatures[i];
                 try {
                     const existingMatch = this.findExisting(sourceObj, targetFeatures, (f) => [f.title, f.description]);
+                    if (existingMatch) {
+                        alreadyPresentCount++;
+                    }
                     if (!existingMatch) {
                         const rawSource = sourceObj;
                         // Resolved just before the write: a keyword is only created in the target
@@ -809,6 +828,9 @@ export class MatterportTagCopyService {
                     const sourceMeasurement = sourceMeasurements[i];
                     try {
                         const existsInTarget = targetMeasurements.some(tm => tm.comment.title === sourceMeasurement.comment.title);
+                        if (existsInTarget) {
+                            alreadyPresentCount++;
+                        }
                         if (!existsInTarget) {
                             const rawComment = sourceMeasurement.comment;
                             let copiedAnnexe = null;
@@ -868,7 +890,15 @@ export class MatterportTagCopyService {
             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);
+                    // Compared on the parsed position, where the copy WOULD land: the stored strings
+                    // differ in format ('{ "x":' vs '{"x":') and, once landmarks move the tags, the
+                    // source string never equals its copy's, so every re-run duplicated these POIs.
+                    const expectedPosition = this.parseCoordinate(this.getAdjustedPositionOnly(sourcePoi.coordinate, transform));
+                    const existsInTarget = targetPois.some(tp => tp.tagDescription === sourcePoi.tagDescription
+                        && this.isSamePosition(this.parseCoordinate(tp.coordinate), expectedPosition));
+                    if (existsInTarget) {
+                        alreadyPresentCount++;
+                    }
                     if (!existsInTarget) {
                         const elementID = sourcePoi.elementID
                             ? (elementIds[sourcePoi.elementID] || sourcePoi.elementID)
@@ -903,6 +933,10 @@ export class MatterportTagCopyService {
             if (healedCount > 0) {
                 this.setStepLog('healedSummary', this.translate.instant('matterportCopy.healedSummary', { count: healedCount }));
             }
+            // Says plainly that a re-run created nothing new, instead of a bare "success".
+            if (alreadyPresentCount > 0) {
+                this.setStepLog('alreadyPresentSummary', this.translate.instant('matterportCopy.alreadyPresentSummary', { count: alreadyPresentCount }));
+            }
             return true;
         }
         catch (error) {
@@ -1659,6 +1693,28 @@ export class MatterportTagCopyService {
             yRotation: applyRigidTransformToYRotationDeg(parsed.yRotation, transform)
         };
     }
+    /**
+     * Reads a stored coordinate (JSON string or object, whatever its spacing) as a position.
+     * Null for a virtual POI or an unreadable value.
+     */
+    parseCoordinate(value) {
+        try {
+            const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+            return parsed && typeof parsed.x === 'number'
+                ? { x: parsed.x, y: parsed.y, z: parsed.z }
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Two positions within 1 cm are the same (two virtual POIs, both null, are too). */
+    isSamePosition(a, b, toleranceM = 0.01) {
+        if (!a || !b) {
+            return !a && !b;
+        }
+        return distance(a, b) <= toleranceM;
+    }
     /**
      * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,
      * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored
@@ -1884,11 +1940,401 @@ export class MatterportTagCopyService {
         // for the CopySource header. Do NOT re-encode it here.
         return extracted;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatterportTagCopyService, deps: [{ token: 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.HashtagService }, { token: i11.MissionService }, { token: i12.OperationService }, { token: i13.DomainService }, { token: i14.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    /**
+     * Both tag lists a recalibration can offer for a target space, computed in one pass. Only
+     * the target location's own tags are ever listed (see RecalibrationTagScope); tags whose
+     * element was deleted — orphan POIs — never are.
+     *  - `space`: every tag of the location, in any of its visits;
+     *  - `visit`: the tags of the location sitting on the sweeps of the selected target visit
+     *    (`options.targetNodeId`); empty when no visit is given.
+     * With `options.onlyTagsInSource` and a source other than the target, both lists only keep
+     * the tags that also exist in the source location (same identity as the copy's duplicate
+     * detection): typically the tags an earlier copy brought over.
+     *
+     * A POI carries no name of its own: each tag gets `elementName`, the name of the element
+     * it points at (ticket title, equipment name, ...).
+     */
+    async getRecalibrationTagSets(sourceSpaceId, targetSpaceId, options = {}) {
+        if (!sourceSpaceId || !targetSpaceId) {
+            return { space: [], visit: [] };
+        }
+        const filterBySource = !!options.onlyTagsInSource && sourceSpaceId !== targetSpaceId;
+        const [targetTags, sourceTags] = await Promise.all([
+            this.loadLiveTagsForSpace(targetSpaceId, options.targetNodeId),
+            filterBySource ? this.loadLiveTagsForSpace(sourceSpaceId) : Promise.resolve(null)
+        ]);
+        const sourceKeys = sourceTags && new Set(sourceTags.filter(tag => tag.ownedBySpace).map(tag => tag.identity));
+        const ownTargetTags = targetTags
+            .filter(tag => tag.ownedBySpace)
+            .filter(tag => !sourceKeys || sourceKeys.has(tag.identity));
+        return {
+            space: ownTargetTags.map(tag => tag.poi),
+            visit: ownTargetTags.filter(tag => tag.inVisit).map(tag => tag.poi)
+        };
+    }
+    /**
+     * Signed, displayable URL of a tag's picture (`elementImageKey`). Meant to be called on
+     * demand — when the tag is previewed — rather than for the whole list.
+     */
+    async getTagImageUrl(imageKey) {
+        const key = this.extractS3KeyFromValue(imageKey);
+        return key ? getSignedFile(key) : null;
+    }
+    /**
+     * Loads the POIs placed on the sweeps of a space whose element still exists, each with a
+     * display name, an identity key and whether its element belongs to that space. The key
+     * follows the same rules as the copy's duplicate detection (findExisting), so a tag and its
+     * copy in another space share the same key. With a visit node, `inVisit` tells whether the
+     * tag sits on one of that visit's sweeps.
+     */
+    async loadLiveTagsForSpace(spaceId, visitNodeId) {
+        const [pois, elements, zones] = await Promise.all([
+            this.navigationService.getAllowedSweepsIDsForUserInSpace(spaceId)
+                .then(sweepIds => this.poiService.getPoisByMatterportSweeps(sweepIds)),
+            this.getTagElementsForSpace(spaceId),
+            this.zoneService.getZonesBySpace(spaceId).catch(error => {
+                console.error('Failed to load the zones of the space:', error);
+                return [];
+            })
+        ]);
+        const sweepZones = this.getSweepZones(zones || []);
+        const visitSweeps = visitNodeId ? await this.getSweepsOfVisit(visitNodeId, zones || []) : new Set();
+        // A POI can point at an element stored under another space (left behind by an earlier
+        // copy): those are not in the space-wide lists and are fetched by ID.
+        const unresolved = (pois || []).filter(poi => poi?.elementID && !elements.has(poi.elementID));
+        await this.fetchTagElementsById(unresolved, elements);
+        const result = [];
+        for (const poi of pois || []) {
+            if (!poi) {
+                continue;
+            }
+            let element;
+            if (poi.elementID) {
+                element = elements.get(poi.elementID);
+                if (!element) {
+                    continue; // orphan: the element was deleted (or cannot be read)
+                }
+            }
+            else {
+                // standalone tag: its description is all that identifies it
+                const description = this.stripHtml(poi.tagDescription);
+                element = { name: description, identity: [description] };
+            }
+            const zones = sweepZones.get(poi.matterportSweepID);
+            result.push({
+                poi: {
+                    ...poi,
+                    elementName: element.name,
+                    elementDescription: element.description,
+                    elementImageKey: element.imageKey,
+                    floorName: zones?.floor,
+                    zoneName: zones?.zone
+                },
+                identity: this.identityKey([poi.type, ...element.identity]),
+                // decided by the element's own spaceID rather than by its presence in the
+                // space-wide lists, some of which are not paginated. A standalone tag has no
+                // element to tell: it belongs to every space that shows it.
+                ownedBySpace: !poi.elementID || element.spaceId === spaceId,
+                inVisit: visitSweeps.has(poi.matterportSweepID)
+            });
+        }
+        return result;
+    }
+    /**
+     * Sweeps of a virtual visit (a Node): those of the space's zones attached to that node,
+     * else — zones not filled in for this visit — the sweeps of the node's navigations.
+     */
+    async getSweepsOfVisit(nodeId, zones) {
+        const sweeps = new Set(zones
+            .filter(zone => zone.nodeIDs?.includes(nodeId))
+            .flatMap(zone => zone.sweepIDs || []));
+        if (sweeps.size === 0) {
+            try {
+                const navigations = await this.navigationService.getNavigationsForNode(nodeId);
+                navigations.forEach(navigation => navigation.matterportSweepID && sweeps.add(navigation.matterportSweepID));
+            }
+            catch (error) {
+                console.error('Failed to load the sweeps of the visit:', error);
+            }
+        }
+        return sweeps;
+    }
+    /**
+     * Maps each sweep of a space to the names of its floor (zone of layer FLOOR) and of its
+     * most specific other zone (the one holding the fewest sweeps, typically a room, else the
+     * visit's BUILDING zone).
+     */
+    getSweepZones(zones) {
+        const bySweep = new Map();
+        const isFloor = (zone) => (zone.layer?.name || '').includes('FLOOR');
+        const zoneRank = new Map(); // sweep -> sweep count of the zone kept so far
+        for (const zone of zones) {
+            for (const sweepId of zone.sweepIDs || []) {
+                const entry = bySweep.get(sweepId) || {};
+                if (isFloor(zone)) {
+                    entry.floor = entry.floor || zone.name;
+                }
+                else {
+                    const size = zone.sweepIDs.length;
+                    if (!zoneRank.has(sweepId) || size < zoneRank.get(sweepId)) {
+                        zoneRank.set(sweepId, size);
+                        entry.zone = zone.name;
+                    }
+                }
+                bySweep.set(sweepId, entry);
+            }
+        }
+        return bySweep;
+    }
+    /**
+     * Indexes, by ID, every element of a space a POI can point at. Each list is fetched
+     * independently: one failing (module not enabled, missing permission) must not hide the
+     * others — their POIs are then resolved one by one by fetchTagElementsById().
+     */
+    async getTagElementsForSpace(spaceId) {
+        const elements = new Map();
+        const [tickets, equipments, objects3D, features, comments] = await Promise.allSettled([
+            this.ticketService.getTicketsBySpace(spaceId),
+            this.equipmentService.getEquipmentsForSpace(spaceId),
+            this.object3DService.getObjects3DBySpace(spaceId),
+            this.featureService.getAllFeaturesBySpaceRaw(spaceId),
+            // a measurement POI is bound to the measurement's Comment, not to the measurement
+            this.commentService.getCommentsBySpaceID(spaceId)
+        ]);
+        const index = (settled, type) => {
+            if (settled.status === 'fulfilled') {
+                settled.value?.forEach(item => {
+                    if (item?.id) {
+                        elements.set(item.id, this.toTagElement(type, { spaceID: spaceId, ...item }));
+                    }
+                });
+            }
+        };
+        index(tickets, 'ticket');
+        index(equipments, 'equipment');
+        index(objects3D, 'object3D');
+        index(features, 'feature');
+        index(comments, 'comment');
+        return elements;
+    }
+    /**
+     * Fetches by ID the elements the space-wide lists did not return. The IDs are packed into
+     * a few GraphQL requests using aliases (`e0: getTicket(id: ...) e1: getEquipment(...)`),
+     * instead of one request per element: a space can hold over a thousand orphan POIs.
+     * An element that no longer exists comes back as null and is simply not indexed.
+     */
+    async fetchTagElementsById(pois, elements) {
+        const IDS_PER_REQUEST = 100;
+        const queries = {
+            ticket: 'getTicket(id: $ID) { id spaceID title description }',
+            equipment: 'getEquipment(id: $ID) { id spaceID name serialNumber }',
+            object3D: 'getObject3D(id: $ID) { id spaceID name description }',
+            comment: 'getComment(id: $ID) { id spaceID title description annexe }',
+            feature: 'getFeature(id: $ID) { id spaceID title description }'
+        };
+        const pending = new Map();
+        for (const poi of pois) {
+            pending.set(poi.elementID, this.tagElementTypeOf(poi.type));
+        }
+        const entries = [...pending.entries()];
+        const batches = [];
+        for (let i = 0; i < entries.length; i += IDS_PER_REQUEST) {
+            batches.push(entries.slice(i, i + IDS_PER_REQUEST));
+        }
+        await Promise.all(batches.map(async (batch) => {
+            const fields = batch.map(([id, type], i) => `e${i}: ${queries[type].replace('$ID', JSON.stringify(id))}`);
+            let data;
+            try {
+                data = (await API.graphql(graphqlOperation(`query TagElements { ${fields.join('\n')} }`))).data;
+            }
+            catch (error) {
+                // Amplify rejects when ANY alias errors (e.g. an unreadable record), but still
+                // hands over the data of the aliases that succeeded.
+                data = error?.data;
+                if (!data) {
+                    console.error('Failed to fetch tag elements by ID:', error);
+                    return;
+                }
+            }
+            batch.forEach(([id, type], i) => {
+                const item = data[`e${i}`];
+                if (item) {
+                    elements.set(id, this.toTagElement(type, item));
+                }
+            });
+        }));
+    }
+    /**
+     * Moves a stored coordinate. Only the position and the horizontal orientation change:
+     * every other key is kept as is. A coordinate often carries the tag's orientation next to
+     * its position ({x, y, z, xRotation, yRotation}); rebuilding it from the position alone
+     * silently erased that orientation.
+     */
+    getRecalibratedCoordinate(coordinate, transform) {
+        const position = applyRigidTransformToPoint({ x: coordinate.x, y: coordinate.y, z: coordinate.z }, transform);
+        const moved = { ...coordinate, x: position.x, y: position.y, z: position.z };
+        if ('yRotation' in coordinate) {
+            moved.yRotation = applyRigidTransformToYRotationDeg(coordinate.yRotation, transform);
+        }
+        return moved;
+    }
+    /**
+     * Reads POIs by ID, 100 per GraphQL request (aliases). Missing POIs are skipped. Amplify
+     * rejects a request when ANY alias errors, but still hands over the data of the others:
+     * those are kept, so one unreadable POI does not hide the 99 others of its batch.
+     */
+    async fetchPoisById(ids) {
+        const IDS_PER_REQUEST = 100;
+        const uniqueIds = [...new Set(ids)];
+        const batches = [];
+        for (let i = 0; i < uniqueIds.length; i += IDS_PER_REQUEST) {
+            batches.push(uniqueIds.slice(i, i + IDS_PER_REQUEST));
+        }
+        const results = await Promise.all(batches.map(async (batch) => {
+            const fields = batch.map((id, i) => `p${i}: getPOI(id: ${JSON.stringify(id)}) { id coordinate metadata }`);
+            let data;
+            try {
+                data = (await API.graphql(graphqlOperation(`query SelectedPois { ${fields.join('\n')} }`))).data;
+            }
+            catch (error) {
+                data = error?.data;
+                if (!data) {
+                    console.error('Failed to read the selected POIs:', error);
+                    return [];
+                }
+            }
+            return batch.map((_, i) => data[`p${i}`]).filter(poi => !!poi);
+        }));
+        return results.flat();
+    }
+    tagElementTypeOf(poiType) {
+        switch (poiType) {
+            case PoiType.TICKET: return 'ticket';
+            case PoiType.EQUIPMENT: return 'equipment';
+            case PoiType.OBJECT3D: return 'object3D';
+            case PoiType.MEASURE: return 'comment';
+            default: return 'feature';
+        }
+    }
+    /** Display name + identity fields of an element, per the copy's duplicate-detection rules. */
+    toTagElement(type, item) {
+        const spaceId = item.spaceID;
+        const text = (value) => this.stripHtml(value) || undefined;
+        switch (type) {
+            case 'equipment':
+                return { name: item.name || '', identity: [item.name, item.serialNumber], spaceId, description: text(item.description) };
+            case 'object3D':
+                return { name: item.name || '', identity: [item.name], spaceId, description: text(item.description) };
+            case 'comment':
+                // A measurement's title is usually empty: its description holds the dimensions and
+                // becomes the name. Its picture is the screenshot taken when it was measured.
+                return {
+                    name: item.title || item.description || '',
+                    identity: [item.title, item.description],
+                    spaceId,
+                    description: item.title ? text(item.description) : undefined,
+                    imageKey: item.annexe || undefined
+                };
+            default:
+                return { name: item.title || '', identity: [item.title, item.description], spaceId, description: text(item.description) };
+        }
+    }
+    stripHtml(value) {
+        return (value || '').replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+    }
+    /**
+     * Recalibrates a specific list of existing tags in the target space by applying the rigid
+     * transformation calculated from the selected landmark points.
+     *
+     * Each tag is updated on its own: a failing update is logged and counted, it no longer
+     * stops the remaining tags. Progress and log go through copyProgress$ / copyLog$, like a
+     * copy (phase 'recalibrating'). `tagLabels` (tag id -> name) only makes the log readable.
+     */
+    async recalibrateTagsFromVisit(targetSpaceId, selectedTagIds, landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB, tagLabels = {}) {
+        const result = { updated: 0, skipped: 0, failed: 0 };
+        const uniqueIds = [...new Set(selectedTagIds)];
+        const total = uniqueIds.length;
+        const label = (id) => tagLabels[id] || `#${id.substring(0, 8)}`;
+        let processed = 0;
+        const emitProgress = (phase) => {
+            this.copyProgress$.next({
+                phase,
+                processedInPhase: processed, totalInPhase: total,
+                processedOverall: processed, totalOverall: total,
+                percent: total > 0 ? Math.round((processed / total) * 100) : 100,
+                errorCount: result.failed, healedCount: 0
+            });
+            this.setStepLog('recalibrating', this.translate.instant('matterportCopy.recalibrateStep', { processed, total }));
+        };
+        this.resetLog();
+        emitProgress('recalibrating');
+        try {
+            const transform = computeRigidTransform(landmarkSourceA, landmarkTargetA, landmarkSourceB, landmarkTargetB);
+            // Re-read only the selected POIs, by ID, so the transform is applied to their current
+            // position — scanning the whole space again for a handful of tags was the slow path.
+            const targetPois = await this.fetchPoisById(uniqueIds);
+            const foundIds = new Set(targetPois.map(poi => poi.id));
+            uniqueIds.filter(id => !foundIds.has(id)).forEach(id => {
+                result.skipped++;
+                processed++;
+                this.appendErrorLog(this.translate.instant('matterportCopy.recalibrateNotFound', { name: label(id) }));
+            });
+            emitProgress('recalibrating');
+            const UPDATES_IN_PARALLEL = 10;
+            for (let i = 0; i < targetPois.length; i += UPDATES_IN_PARALLEL) {
+                await Promise.all(targetPois.slice(i, i + UPDATES_IN_PARALLEL).map(async (poi) => {
+                    const id = poi.id;
+                    try {
+                        let originalCoord = null;
+                        try {
+                            originalCoord = typeof poi.coordinate === 'string'
+                                ? JSON.parse(poi.coordinate)
+                                : poi.coordinate;
+                        }
+                        catch {
+                            originalCoord = null;
+                        }
+                        if (!originalCoord || typeof originalCoord.x !== 'number') {
+                            // virtual POI or unreadable coordinate: no position to move
+                            result.skipped++;
+                            this.appendErrorLog(this.translate.instant('matterportCopy.recalibrateSkipped', { name: label(id) }));
+                            return;
+                        }
+                        await this.poiService.updatePoi({
+                            id,
+                            coordinate: JSON.stringify(this.getRecalibratedCoordinate(originalCoord, transform)),
+                            metadata: this.getAdjustedPoiMetadata(poi.metadata, transform)
+                        });
+                        result.updated++;
+                    }
+                    catch (error) {
+                        result.failed++;
+                        console.error(`Failed to recalibrate the tag ${id}:`, error);
+                        this.appendErrorLog(this.translate.instant('matterportCopy.recalibrateError', { name: label(id), error: toErrorMessage(error) }));
+                    }
+                    finally {
+                        processed++;
+                        emitProgress('recalibrating');
+                    }
+                }));
+            }
+        }
+        catch (error) {
+            // transform or reading failure: nothing left can be moved
+            console.error('Erreur lors du recalibrage des tags:', error);
+            result.failed = total - result.updated - result.skipped;
+            processed = total;
+            this.appendErrorLog(this.translate.instant('matterportCopy.errorGeneral', { error: toErrorMessage(error) }));
+        }
+        emitProgress('done');
+        this.setStepLog('done', this.translate.instant('matterportCopy.recalibrateSummary', result));
+        return result;
+    }
+    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.HashtagService }, { token: i11.MissionService }, { token: i12.OperationService }, { token: i13.DomainService }, { token: i14.TranslateService }, { token: i15.ZoneService }], 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.HashtagService }, { type: i11.MissionService }, { type: i12.OperationService }, { type: i13.DomainService }, { type: i14.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';\nimport { BehaviorSubject } from 'rxjs';\nimport { TranslateService } from '@ngx-translate/core';\nimport { POI } from '../types.service';\nimport { NavigationService } from './models/navigation.service';\nimport { PoiService } from './models/poi.service';\nimport { TicketsService } from './models/ticket.service';\nimport { EquipmentService } from './models/equipment.service';\nimport { Object3DService } from './models/object3D.service';\nimport { FeatureService } from './models/feature.service';\nimport { MeasurementService } from './models/measurement.service';\nimport { CommentService } from './models/comment.service';\nimport { HashtagService } from './models/hashtag.service';\nimport { MissionService } from './models/mission.service';\nimport { OperationService } from './models/operation.service';\nimport { DomainService } from './models/domain.service';\nimport { BaseUserService } from './user.service';\nimport { copyFileInS3, copyFileInS3ViaDownload } from './s3.service'; // see s3.service.ts: neither must swallow errors (needed to detect NoSuchKey / signature mismatch below)\nimport { downloadBlob } from '../helpers.service';\nimport {\n    computeRigidTransform, applyRigidTransformToPoint, applyRigidTransformToDirection,\n    applyRigidTransformToYRotationDeg, RigidTransform, Vec3\n} from './utils/matterport-transform.util';\nimport { Object3D, Feature, Measurement, Comment, CommentType, PoiType, Equipment, SpModule, Ticket, Hashtag, Mission, Operation, Domain } from '../types.service';\n\n/** Progress snapshot emitted during copyTagsFromVisit(), so the UI can show a live status. */\nexport interface CopyProgress {\n    phase: 'collecting' | 'tickets' | 'equipments' | 'pois' | 'objects3d' | 'features' | 'measurements' | 'done';\n    processedInPhase: number;\n    totalInPhase: number;\n    processedOverall: number;\n    totalOverall: number;\n    percent: number;\n    errorCount: number;\n    /** Items that already existed in the target space and had missing identity fields\n     *  filled in, rather than being newly created — see healEquipmentIdentity() and its\n     *  ticket/feature equivalents. */\n    healedCount: number;\n}\n\n/** A single line in the copy log — a step status (updated in place), or an error / healed\n *  item notice (appended once, permanent). */\nexport interface CopyLogEntry {\n    id: string;       // stable id for step lines (so they update in place), unique for error/healed lines\n    type: 'step' | 'error' | 'healed';\n    text: string;\n}\n\n/** Safely extracts a readable message from an unknown catch value, including Amplify's\n *  GraphQL error shape ({ data, errors: [{ errorType, message }] }). */\nfunction toErrorMessage(err: unknown): string {\n    if (err && typeof err === 'object') {\n        const anyErr = err as any;\n        if (Array.isArray(anyErr.errors) && anyErr.errors.length > 0) {\n            return anyErr.errors\n                .map((e: any) => {\n                    const title = e.errorType ? `${e.errorType}: ` : '';\n                    return `${title}${e.message || 'Unknown error'}`;\n                })\n                .join(' | ');\n        }\n        if (err instanceof Error) {\n            return err.message;\n        }\n    }\n    if (typeof err === 'string') {\n        return err;\n    }\n    try {\n        return JSON.stringify(err);\n    } catch {\n        return String(err);\n    }\n}\n\n/** Thrown when the referenced S3 source file doesn't exist (orphaned DB reference —\n *  e.g. the file was deleted or renamed on S3 without updating the database).\n *  Kept distinct from other copy failures so the calling loop can log a clear,\n *  specific message and skip the whole item instead of a generic error. */\nclass MissingS3FileError extends Error {\n    constructor(public readonly sourceKey: string, public readonly contextLabel: string) {\n        super(`Source file missing on S3: \"${sourceKey}\" (${contextLabel})`);\n        this.name = 'MissingS3FileError';\n    }\n}\n\n@Injectable({ providedIn: 'root' })\nexport class MatterportTagCopyService {\n\n    // Emits progress updates during copyTagsFromVisit(); null when idle\n    public copyProgress$: BehaviorSubject<CopyProgress | null> = new BehaviorSubject<CopyProgress | null>(null);\n\n    // Emits the accumulated log lines during copyTagsFromVisit(); [] when idle\n    public copyLog$: BehaviorSubject<CopyLogEntry[]> = new BehaviorSubject<CopyLogEntry[]>([]);\n\n    private spModule: SpModule;\n    private log: CopyLogEntry[] = [];\n    /** Unique-id sequence shared by every permanent (non-step) log line — errors and healed-item notices alike. */\n    private logSeq = 0;\n\n    // ---- Per-run remapping state (reset by resetRunState() at the start of every copy) ----\n\n    /** source element id -> id of its copy in the target space. */\n    private elementIds: Record<string, string> = {};\n\n    /** source Comment id -> id of its copy. Needed to remap POI.tagImageID, which is a\n     *  reference to a Comment record (see the schema: \"connection to comment.id\"). */\n    private commentIds: Map<string, string> = new Map();\n\n    // Hashtags are space-scoped records, so their ids can never be carried over as-is: they\n    // are matched by NAME against the target space, and the missing ones are created there.\n    // That creation is deliberately lazy — see resolveHashtagIds() — and audited, so an\n    // interrupted copy cannot leave keywords behind that no POI references.\n\n    /** source Hashtag id -> its name. */\n    private sourceHashtagNames: Map<string, string> = new Map();\n\n    /** normalised hashtag name -> its id in the TARGET space (pre-existing or just created). */\n    private targetHashtagIdsByName: Map<string, string> = new Map();\n\n    /** ids of the hashtags this run created in the target space. */\n    private createdHashtagIds: Set<string> = new Set();\n\n    /** ids of the hashtags actually persisted on a successfully created feature. Anything in\n     *  createdHashtagIds but absent here is an orphan and is deleted at the end of the run. */\n    private usedHashtagIds: Set<string> = new Set();\n\n    /** source ids of the elements whose POIs were already created by an element phase.\n     *  Guards the standalone POI phase against creating a second, impoverished copy. */\n    private handledElementIds: Set<string> = new Set();\n\n    // Comment authorship: `Comment.ownerID` is a foreign key to a Mission, and a Mission is\n    // scoped to ONE space (userID + spaceID). A source comment's ownerID therefore points at\n    // nobody in the target space, so it has to be translated to the Mission of the SAME user\n    // there — see resolveCommentOwnerID().\n\n    /** source Mission id -> its userID. */\n    private sourceMissionUserIds: Map<string, string> = new Map();\n\n    /** userID -> that user's Mission id in the TARGET space (only set when they have one). */\n    private targetMissionIdsByUserId: Map<string, string> = new Map();\n\n    // Domain (equipment/ticket/feature/POI category) resolution mirrors the exact rule the\n    // edit forms use to populate their own category dropdown —\n    // DomainService.getDomainsForOrgForType(type, mission.organisationID,\n    // mission.orderedOrganisationID) — keyed to the OPERATOR's own Mission on each space,\n    // NOT to the Space's own organisationID. Two spaces in different organisations can\n    // still share a domain through that Mission link (an operator whose mission on the\n    // target space carries an `orderedOrganisationID` matching the domain's own\n    // organisationID sees — and can reuse — it directly). See resolveDomainID().\n\n    /** id -> Domain, for every domain visible from EITHER space's operator mission (its\n     *  organisationID, its orderedOrganisationID, or generic/no-organisation domains) — a\n     *  superset covering whatever a source object's domainID could point at. */\n    private domainsById: Map<string, Domain> = new Map();\n\n    /** organisationIDs the TARGET operator's mission can see domains from. A domain whose\n     *  own organisationID is in this set (or has none at all) is already directly\n     *  selectable in the target space's own dropdown, so its id is reused unchanged. */\n    private targetVisibleDomainOrgIds: Set<string> = new Set();\n\n    /** `${type}::${normalised name}` -> that domain's id, among domains visible to the\n     *  TARGET operator — used to find an equivalent when the exact id isn't reusable. */\n    private targetDomainIdsByTypeAndName: Map<string, string> = new Map();\n\n    /** Target space id of the run in progress — used to re-home copied tag icons. */\n    private targetSpaceId: string | null = null;\n\n    constructor(\n        private navigationService: NavigationService,\n        private userService: BaseUserService,\n        private poiService: PoiService,\n        private ticketService: TicketsService,\n        private equipmentService: EquipmentService,\n        private object3DService: Object3DService,\n        private featureService: FeatureService,\n        private measurementService: MeasurementService,\n        private commentService: CommentService,\n        private hashtagService: HashtagService,\n        private missionService: MissionService,\n        private operationService: OperationService,\n        private domainService: DomainService,\n        private translate: TranslateService\n    ) {\n        this.spModule = userService.getSpModule();\n    }\n\n    //\n    // ---------- Public API ----------\n    //\n\n    async copyTagsFromVisit(\n        sourceSpaceId: string,\n        targetSpaceId: string,\n        landmarkSourceA: Vec3, landmarkTargetA: Vec3,\n        landmarkSourceB: Vec3, landmarkTargetB: Vec3\n    ): Promise<boolean> {\n        let errorCount = 0;\n        let healedCount = 0;\n        this.resetLog();\n        this.resetRunState(targetSpaceId);\n\n        try {\n            console.log(`Copying Tags from source ${sourceSpaceId} to target ${targetSpaceId}`);\n\n            this.setStepProgress('collecting', 'collecting', 0);\n            this.copyProgress$.next({\n                phase: 'collecting',\n                processedInPhase: 0, totalInPhase: 0,\n                processedOverall: 0, totalOverall: 0,\n                percent: 0, errorCount: 0, healedCount: 0\n            });\n\n            const targetMission = this.userService.currentMission(targetSpaceId);\n            const targetMissionId = targetMission ? targetMission.id : null;\n\n            const transform: RigidTransform = computeRigidTransform(\n                landmarkSourceA, landmarkTargetA,\n                landmarkSourceB, landmarkTargetB\n            );\n            console.log('Rigid transform computed:', {\n                rotationYDeg: transform.rotationYRad * (180 / Math.PI),\n                refSource: transform.refSource,\n                refTarget: transform.refTarget\n            });\n\n            const sourceSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(sourceSpaceId);\n            const targetSweepIds = await this.navigationService.getAllowedSweepsIDsForUserInSpace(targetSpaceId);\n\n            this.setStepProgress('collecting', 'collecting', 30);\n\n            const [sourceNavPositions, targetNavPositions] = await Promise.all([\n                this.buildNavigationPositionMap(sourceSpaceId, sourceSweepIds),\n                this.buildNavigationPositionMap(targetSpaceId, targetSweepIds)\n            ]);\n\n            const elementIds = this.elementIds;\n\n            let sourceTickets: Ticket[] = [];\n            let sourceEquipments: Equipment[] = [];\n            let targetTickets: Ticket[] = [];\n            let targetEquipments: Equipment[] = [];\n            let sourceMeasurements: Measurement[] = [];\n            let targetMeasurements: Measurement[] = [];\n\n            if (this.spModule == SpModule.IMMO) {\n                sourceTickets = await this.ticketService.getTicketsBySpace(sourceSpaceId);\n                sourceEquipments = await this.equipmentService.getEquipmentsForSpace(sourceSpaceId);\n                targetTickets = await this.ticketService.getTicketsBySpace(targetSpaceId);\n                targetEquipments = await this.equipmentService.getEquipmentsForSpace(targetSpaceId);\n            }\n\n            this.setStepProgress('collecting', 'collecting', 55);\n\n            const sourceObjects3D = await this.object3DService.getObjects3DBySpace(sourceSpaceId);\n            const targetObjects3D = await this.object3DService.getObjects3DBySpace(targetSpaceId);\n\n            // Paginated: a space routinely holds more than the 100 features a single AppSync\n            // page returns, and the tail was silently dropped.\n            //\n            // The source list keeps the historical \"skip what the operator archived\" rule, so\n            // the set of copied features does not change — but the check is now null-safe:\n            // FeatureService.isArchived() dereferences currentMission(spaceID).id and threw a\n            // TypeError when the operator had no mission on the source space (the common case\n            // for an archived v1 space), aborting the whole copy.\n            // The target list is NOT filtered: it only feeds duplicate detection, and an\n            // archived feature is still a feature that exists there.\n            const sourceFeatures = (await this.featureService.getAllFeaturesBySpaceRaw(sourceSpaceId))\n                .filter(feature => !this.isArchivedForOperator(feature, sourceSpaceId));\n            const targetFeatures = await this.featureService.getAllFeaturesBySpaceRaw(targetSpaceId);\n\n            this.setStepProgress('collecting', 'collecting', 75);\n\n            // Keywords: index both vocabularies now (read-only). The keywords the target space\n            // is missing are created later, POI by POI, only for those actually used.\n            await this.loadHashtagIndex(sourceSpaceId, targetSpaceId);\n\n            // Missions: index both spaces now (read-only), so copied comments can credit\n            // their real author instead of whoever is running the copy.\n            await this.loadMissionIndex(sourceSpaceId, targetSpaceId);\n\n            // Domains: index every domain either operator's mission can see (read-only), so\n            // a category survives a copy across two DIFFERENT organisations whenever it\n            // genuinely would be selectable in the target space's own dropdown — see\n            // loadDomainIndex() for why this is keyed to Mission, not to the Space itself.\n            await this.loadDomainIndex(sourceSpaceId, targetSpaceId);\n\n            if (this.spModule == SpModule.IMMO) {\n                sourceMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId);\n                targetMeasurements = await this.measurementService.getMeasurementsForSpaceForUser(targetSpaceId);\n            }\n\n            this.setStepProgress('collecting', 'collecting', 90);\n\n            const sourcePoisAll = await this.poiService.getPoisByMatterportSweeps(sourceSweepIds);\n            const targetPoisAll = await this.poiService.getPoisByMatterportSweeps(targetSweepIds);\n\n            // A POI is \"owned\" by an element (ticket, equipment, 3D object, feature, measurement)\n            // when its elementID points at one. Those POIs are created by their element's phase,\n            // which is the only place that knows the element's NEW id — so they must be excluded\n            // from the standalone phase, otherwise every feature ends up with two POIs: one\n            // correctly linked but stripped of its tag metadata, and one carrying the metadata\n            // but still pointing at the source space's element.\n            //\n            // Ownership is recognised by TWO independent criteria, and either one is enough to\n            // keep a POI out of the standalone phase:\n            //\n            //  - its type is one an element phase is responsible for. This is the historical\n            //    rule and it must be kept: a POI of that type whose element was NOT collected\n            //    (deleted ticket, equipment outside the current filter, ...) is an orphan, and\n            //    copying it standalone would recreate it with an elementID still pointing into\n            //    the source space — an orphan the previous version correctly refused to copy.\n            //  - its elementID belongs to an element we actually collected. This is the added\n            //    rule, needed because the type alone is not a reliable discriminator: historical\n            //    data also holds INFORMATION/ROOM POIs bound to a feature, which the type test\n            //    lets through and which would end up duplicated.\n            const handledPoiTypes = new Set<string>([\n                PoiType.TICKET, PoiType.EQUIPMENT, PoiType.DATA, PoiType.DESK,\n                PoiType.OBJECT3D, PoiType.MEASURE\n            ]);\n\n            for (const owner of [...sourceTickets, ...sourceEquipments, ...sourceObjects3D, ...sourceFeatures]) {\n                if (owner?.id) {\n                    this.handledElementIds.add(owner.id);\n                }\n            }\n            for (const measurement of sourceMeasurements) {\n                // a measurement POI is bound to the measurement's Comment, not to the measurement\n                if (measurement?.comment?.id) {\n                    this.handledElementIds.add(measurement.comment.id);\n                }\n            }\n\n            const isOwnedByAnElement = (poi: POI) =>\n                handledPoiTypes.has(poi.type as string)\n                || (!!poi.elementID && this.handledElementIds.has(poi.elementID));\n\n            const sourcePois = sourcePoisAll.filter(p => !isOwnedByAnElement(p));\n            const targetPois = targetPoisAll.filter(p => !!p);\n\n            this.setStepProgress('collecting', 'collecting', 100);\n\n            const totalOverall = sourceTickets.length + sourceEquipments.length + sourcePois.length\n                + sourceObjects3D.length + sourceFeatures.length + sourceMeasurements.length;\n            let processedOverall = 0;\n\n            const emitProgress = (phase: CopyProgress['phase'], processedInPhase: number, totalInPhase: number) => {\n                this.copyProgress$.next({\n                    phase,\n                    processedInPhase,\n                    totalInPhase,\n                    processedOverall,\n                    totalOverall,\n                    percent: totalOverall > 0 ? Math.round((processedOverall / totalOverall) * 100) : 0,\n                    errorCount, healedCount\n                });\n            };\n\n            if (this.spModule == SpModule.IMMO) {\n                // TICKETS\n                for (let i = 0; i < sourceTickets.length; i++) {\n                    const sourceObj = sourceTickets[i];\n\n                    try {\n                        const existingMatch = this.findExisting(\n                            sourceObj as any, targetTickets as any,\n                            (t: any) => [t.title, t.description]\n                        );\n\n                        if (!existingMatch) {\n                            const rawSource = sourceObj as any;\n\n                            const ticketInput: any = {\n                                title: rawSource.title,\n                                friendlyLabel: rawSource.friendlyLabel,\n                                status: rawSource.status,\n                                type: rawSource.type,\n                                priority: rawSource.priority,\n                                description: rawSource.description,\n                                level: rawSource.level,\n                                metadata: rawSource.metadata || null,\n                                read: rawSource.read || null,\n                                projectID: rawSource.projectID || null,\n                                problemCode: rawSource.problemCode || null,\n                                // Missions are per-space: a source mission id designates nobody in\n                                // the target space. Carrying the list over would look like real data\n                                // while hiding the item from no one — reset it, as for features.\n                                archivedForMissionID: null,\n                                spaceID: targetSpaceId,\n                                // Remapped in the second pass below, once every ticket exists.\n                                parentID: null,\n                                // Reused unchanged in the same organisation, matched by name\n                                // across two — see resolveDomainID().\n                                domainID: this.resolveDomainID(rawSource.domainID),\n                                ownerMissionID: targetMissionId\n                            };\n\n                            const createdObj = await this.ticketService.createTicket(ticketInput);\n\n                            if (createdObj && createdObj.id) {\n                                elementIds[sourceObj.id] = createdObj.id;\n                            }\n\n                            // Attachments of the ticket (photos of the incident, documents...).\n                            // They were never copied at all: a duplicated ticket arrived stripped\n                            // of every piece of evidence attached to it.\n                            if (createdObj) {\n                                let sourceComments: Comment[] = [];\n                                try {\n                                    sourceComments = await this.commentService.getAllCommentsForTicket(sourceObj.id);\n                                } catch (commentsFetchError) {\n                                    console.warn(`Falling back to the embedded comment list for ticket \"${rawSource.title}\":`, commentsFetchError);\n                                    sourceComments = (sourceObj.comments?.items || []).filter(c => !!c) as Comment[];\n                                }\n\n                                for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {\n                                    try {\n                                        const created = await this.copyCommentForTicket(\n                                            sourceComment, createdObj.id, targetSpaceId\n                                        );\n                                        if (created?.id && (sourceComment as any).id) {\n                                            this.commentIds.set((sourceComment as any).id, created.id);\n                                        }\n                                    } catch (attachmentError) {\n                                        console.error(`Error copying attachment \"${sourceComment?.title}\" for ticket \"${sourceObj?.title}\":`, attachmentError);\n                                        errorCount++;\n                                        this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || (sourceComment as any)?.id, {\n                                            feature: rawSource.title || sourceObj.id\n                                        });\n                                    }\n                                }\n                            }\n\n                            for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {\n                                await this.createCopiedPoi(\n                                    sourcePoi, createdObj.id,\n                                    sourceNavPositions, targetNavPositions, transform\n                                );\n                            }\n                        } else {\n                            // Same reasoning as the EQUIPMENTS phase (see the comment there):\n                            // a ticket matching this one already exists in the target space,\n                            // most likely from an earlier, incomplete run. Fill in whatever\n                            // identity field it is missing rather than leaving it untouched.\n                            elementIds[sourceObj.id] = existingMatch.id;\n                            const healedFields = await this.healTicketIdentity(sourceObj as any, existingMatch as any);\n                            if (healedFields.length > 0) {\n                                healedCount++;\n                                this.logHealedItem('ticketHealed', (sourceObj as any)?.title || sourceObj?.id, healedFields);\n                            }\n                        }\n                    } catch (itemError) {\n                        console.error(`Error copying ticket \"${sourceObj?.title}\" (id: ${sourceObj?.id}):`, itemError);\n                        errorCount++;\n                        this.logCopyItemError(itemError, 'errorTicket', sourceObj?.title || sourceObj?.id);\n                    }\n\n                    processedOverall++;\n                    emitProgress('tickets', i + 1, sourceTickets.length);\n                    const pct = sourceTickets.length > 0 ? Math.round(((i + 1) / sourceTickets.length) * 100) : 100;\n                    this.setStepProgress('tickets', 'tickets', pct);\n                }\n\n                // Second pass: restore the ticket hierarchy. `parentID` had to be nulled during\n                // creation (the parent may not have existed yet) and was then never restored, so\n                // every sub-ticket came out detached. Same rule as for sub-equipments: a parent\n                // with no copied counterpart is dropped rather than left pointing at the source\n                // space's ticket.\n                for (const sourceObj of sourceTickets) {\n                    const rawSource = sourceObj as any;\n                    const newId = elementIds[sourceObj.id];\n                    const newParentId = rawSource.parentID ? elementIds[rawSource.parentID] : null;\n\n                    if (newId && newParentId) {\n                        try {\n                            await this.ticketService.updateTicket({ id: newId, parentID: newParentId });\n                        } catch (parentError) {\n                            console.error(`Error remapping the parent ticket of \"${sourceObj?.title}\":`, parentError);\n                            errorCount++;\n                            this.logCopyItemError(parentError, 'errorTicket', sourceObj?.title || sourceObj?.id);\n                        }\n                    }\n                }\n\n                // EQUIPMENTS (identity, POI, PHOTO and NOTES/documents all copied — files\n                // physically duplicated in S3 first, so the copy stays independent from the source)\n                //\n                // CAREFUL: the Equipment model has NO `title` and NO `description` column. It\n                // identifies itself with `name` (String! — required) and annotates itself with\n                // `annotation`. Reading `rawSource.title` therefore always yielded undefined and\n                // the required `name` was never sent, which AppSync rejected with\n                // \"Variable 'input' has coerced Null value for NonNull type 'String!'\".\n                for (let i = 0; i < sourceEquipments.length; i++) {\n                    const sourceObj = sourceEquipments[i];\n\n                    try {\n                        // Equipment has no `title`/`description`: it identifies itself by name, and by\n                        // serial number when one is recorded.\n                        const existingMatch = this.findExisting(\n                            sourceObj as any, targetEquipments as any,\n                            (e: any) => [e.name, e.serialNumber]\n                        );\n\n                        if (!existingMatch) {\n                            const rawSource = sourceObj as any;\n\n                            let copiedPhotoKey: string | null = null;\n                            if (rawSource.photo) {\n                                copiedPhotoKey = await this.copyS3KeyIfPresent(rawSource.photo, `equipment photo \"${rawSource.name}\"`);\n                            }\n\n                            const equipmentInput: any = {\n                                name: rawSource.name,\n                                // Unlike every other model this file copies, Equipment declares\n                                // `createdAt` as a plain client-settable field rather than an\n                                // AppSync-managed timestamp (see schema.graphql) — so, uniquely\n                                // here, the original commissioning date can actually be kept\n                                // instead of the copy silently getting today's date.\n                                createdAt: rawSource.createdAt ?? null,\n                                annotation: rawSource.annotation ?? null,\n                                status: rawSource.status,\n                                // Full identity of the equipment — all of these were dropped\n                                family: rawSource.family ?? null,\n                                sku: rawSource.sku ?? null,\n                                serialNumber: rawSource.serialNumber ?? null,\n                                manufacturer: rawSource.manufacturer ?? null,\n                                installDate: rawSource.installDate ?? null,\n                                warrantyEndDate: rawSource.warrantyEndDate ?? null,\n                                metadata: rawSource.metadata ?? null,\n                                isCreatedByAI: rawSource.isCreatedByAI ?? null,\n                                // Missions are per-space: a source mission id designates nobody in\n                                // the target space. Carrying the list over would look like real data\n                                // while hiding the item from no one — reset it, as for features.\n                                archivedForMissionID: null,\n                                spaceID: targetSpaceId,\n                                // Reused unchanged in the same organisation, matched by name\n                                // across two — see resolveDomainID().\n                                domainID: this.resolveDomainID(rawSource.domainID),\n                                photo: copiedPhotoKey,\n                                // `subequipmentsIDs` is deliberately absent: it is remapped to the\n                                // copied equipments in the second pass, once they all exist.\n                            };\n\n                            const createdObj: any = await this.equipmentService.createEquipment(equipmentInput, null, null);\n\n                            if (createdObj && createdObj.id) {\n                                elementIds[sourceObj.id] = createdObj.id;\n                            }\n\n                            // Copy notes (documents, technical/financial/other/contractual/image notes)\n                            if (createdObj && rawSource.notes?.items && rawSource.notes.items.length > 0) {\n                                for (const sourceNote of rawSource.notes.items) {\n                                    try {\n                                        // A note without a file is still a note: it carries a type\n                                        // and its signature/expiry dates. Skipping it, as was done\n                                        // before, silently dropped those records entirely.\n                                        const copiedKey = sourceNote.attachment\n                                            ? await this.copyS3KeyIfPresent(sourceNote.attachment, `equipment note for \"${sourceObj?.name}\"`)\n                                            : null;\n                                        await this.equipmentService.createNoteWithExistingAttachment(\n                                            createdObj.id, copiedKey, sourceNote.type, targetMissionId,\n                                            {\n                                                signDate: sourceNote.signDate ?? null,\n                                                expirationDate: sourceNote.expirationDate ?? null\n                                            }\n                                        );\n                                    } catch (noteError) {\n                                        console.error(`Error copying note for equipment \"${sourceObj?.name}\":`, noteError);\n                                        errorCount++;\n                                        this.logCopyItemError(noteError, 'errorEquipmentNote', sourceObj?.name || sourceObj?.id, {\n                                            equipment: sourceObj?.name || sourceObj?.id\n                                        });\n                                    }\n                                }\n                            }\n\n                            for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {\n                                await this.createCopiedPoi(\n                                    sourcePoi, createdObj.id,\n                                    sourceNavPositions, targetNavPositions, transform\n                                );\n                            }\n                        } else {\n                            // An equipment matching this one already exists in the target space —\n                            // most often because a PREVIOUS run of this copy already created it.\n                            // That earlier run may have been interrupted, or hit a bug that has\n                            // since been fixed (missing family/manufacturer/domainID/... were once\n                            // dropped entirely — see the comment above), leaving an equipment with\n                            // its identity fields empty forever: re-running the copy used to skip\n                            // it outright, since it already \"exists\", so the gap could never heal.\n                            //\n                            // Re-running the tool must be able to repair that: any identity field\n                            // the existing target equipment is missing, and the source has, is\n                            // filled in. Fields the target already carries a value for are left\n                            // untouched, so a manual edit made in the target space is never\n                            // overwritten by an older or different source value. Notes and POIs are\n                            // NOT re-created here: unlike scalar fields they cannot be \"missing vs.\n                            // present\" checked the same way, and re-adding them on every re-run of\n                            // an already-healthy copy would duplicate them.\n                            elementIds[sourceObj.id] = existingMatch.id;\n                            const healedFields = await this.healEquipmentIdentity(sourceObj as any, existingMatch as any);\n                            if (healedFields.length > 0) {\n                                healedCount++;\n                                this.logHealedItem('equipmentHealed', (sourceObj as any)?.name || sourceObj?.id, healedFields);\n                            }\n                        }\n                    } catch (itemError) {\n                        console.error(`Error copying equipment \"${sourceObj?.name}\" (id: ${sourceObj?.id}):`, itemError);\n                        errorCount++;\n                        this.logCopyItemError(itemError, 'errorEquipment', sourceObj?.name || sourceObj?.id);\n                    }\n\n                    processedOverall++;\n                    emitProgress('equipments', i + 1, sourceEquipments.length);\n                    const pct = sourceEquipments.length > 0 ? Math.round(((i + 1) / sourceEquipments.length) * 100) : 100;\n                    this.setStepProgress('equipments', 'equipments', pct);\n                }\n\n                // Second pass: remap subequipmentsIDs on newly created equipments to point to\n                // their copied counterparts. IDs with no copied counterpart (source equipment\n                // wasn't copied — e.g. it already existed in target, or was skipped) are dropped\n                // rather than left dangling or pointing back at the source space's equipment.\n                for (const sourceObj of sourceEquipments) {\n                    const rawSource = sourceObj as any;\n                    const newId = elementIds[sourceObj.id];\n                    if (newId && rawSource.subequipmentsIDs && rawSource.subequipmentsIDs.length > 0) {\n                        const remapped = rawSource.subequipmentsIDs\n                            .map((subId: string) => elementIds[subId])\n                            .filter((id: string | undefined) => !!id);\n\n                        if (remapped.length > 0) {\n                            try {\n                                await this.equipmentService.updateEquipment({ id: newId, subequipmentsIDs: remapped });\n                            } catch (subEquipError) {\n                                console.error(`Error remapping sub-equipments for \"${sourceObj?.name}\":`, subEquipError);\n                                errorCount++;\n                                this.logCopyItemError(subEquipError, 'errorEquipmentSubEquip', sourceObj?.name || sourceObj?.id, {\n                                    equipment: sourceObj?.name || sourceObj?.id\n                                });\n                            }\n                        }\n                    }\n                }\n\n                // OPERATIONS — the Ticket<->Equipment join (drives \"Tickets actuels\" on the\n                // equipment page and the linked-equipment list on the ticket page). Both the\n                // TICKETS and EQUIPMENTS phases above copy the record itself, but neither one\n                // touches this join table, so every link between a copied ticket and a copied\n                // equipment was silently dropped: both sides existed in the target space, but\n                // pointing at nobody.\n                //\n                // Runs after both phases, over every SOURCE ticket that ended up mapped in\n                // the target space (freshly created OR healed — elementIds covers both), so a\n                // re-run over an already-copied pair of spaces can still pick up links that\n                // an earlier, incomplete run never created.\n                for (const sourceTicket of sourceTickets) {\n                    const newTicketId = elementIds[sourceTicket.id];\n                    if (!newTicketId) {\n                        continue;\n                    }\n\n                    try {\n                        const sourceOps = await this.operationService.getOperationsByTicketID(sourceTicket.id);\n                        if (sourceOps.length === 0) {\n                            continue;\n                        }\n\n                        // Read what the target ticket is already linked to, so a re-run never\n                        // creates a duplicate Operation for a link that already exists.\n                        const targetOps = await this.operationService.getOperationsByTicketID(newTicketId);\n                        const linkedEquipmentIds = new Set(targetOps.map(op => op.equipmentID));\n\n                        for (const sourceOp of sourceOps) {\n                            const newEquipmentId = sourceOp.equipmentID ? elementIds[sourceOp.equipmentID] : null;\n                            // No copied counterpart for the source equipment (not collected,\n                            // outside the current filter, ...) — same rule as everywhere else\n                            // in this file: drop the link rather than point it at nothing or\n                            // at the source space's equipment.\n                            if (!newEquipmentId || linkedEquipmentIds.has(newEquipmentId)) {\n                                continue;\n                            }\n                            await this.operationService.createOperation({ ticketID: newTicketId, equipmentID: newEquipmentId } as Operation);\n                            linkedEquipmentIds.add(newEquipmentId);\n                        }\n                    } catch (opError) {\n                        console.error(`Error copying ticket-equipment links for \"${sourceTicket?.title}\":`, opError);\n                        errorCount++;\n                        this.logCopyItemError(opError, 'errorOperation', sourceTicket?.title || sourceTicket?.id);\n                    }\n                }\n            }\n\n            // OBJECTS 3D (the 3D model file itself — `path` — is physically duplicated in S3)\n            for (let i = 0; i < sourceObjects3D.length; i++) {\n                const sourceObj = sourceObjects3D[i];\n\n                try {\n                    const existsInTarget = targetObjects3D.some(targetObj => targetObj.name === sourceObj.name);\n\n                    if (!existsInTarget) {\n                        const rawSource = sourceObj as any;\n\n                        // `path` means two different things depending on `s3Bucket`, exactly as the\n                        // viewer reads it (see viewer.component.ts and matterport-object3d.service.ts):\n                        //  - s3Bucket === true  -> a key of a model file uploaded to S3, ours to duplicate;\n                        //  - otherwise          -> a reference into the 3D object library shipped with\n                        //    the application (\"3DObjects/objects/cube.dae\" -> assets/3Dobjects/...),\n                        //    which exists in every space and must be reused verbatim.\n                        // Copying unconditionally meant every library object failed with NoSuchKey and\n                        // the whole 3D object was skipped, model AND POI.\n                        let copiedPath = rawSource.path;\n                        if (rawSource.path && rawSource.s3Bucket) {\n                            copiedPath = await this.copyS3KeyIfPresent(rawSource.path, `3D object \"${rawSource.name}\"`);\n                        }\n\n                        /**\n                         * Strict parser to ensure [float, float, float] format for GraphQL.\n                         * Forces numbers, handles potential DynamoDB object structures,\n                         * and ensures we never send [0,0,0] for scale.\n                         */\n                        const toFloatArray = (val: any, defaultVal: number[] = [0, 0, 0]): number[] => {\n                            let array: number[] = [];\n\n                            if (Array.isArray(val)) {\n                                // If DB format [ {N: \"1\"}, ... ]\n                                if (val.length > 0 && typeof val[0] === 'object' && 'N' in val[0]) {\n                                    array = val.map(item => parseFloat(item.N));\n                                }\n                                // If already standard array [1, 1, 1]\n                                else {\n                                    array = val.map(item => parseFloat(item));\n                                }\n                            }\n                            // If object {x, y, z}\n                            else if (val && typeof val === 'object') {\n                                array = [parseFloat(val.x), parseFloat(val.y), parseFloat(val.z)];\n                            } else {\n                                return defaultVal;\n                            }\n\n                            // Ensure we return valid numbers\n                            return array.map(n => isNaN(n) ? 0 : n);\n                        };\n\n                        // This service is shared, but the two applications do NOT deploy the same\n                        // Object3D schema: `viewFrustum` exists only in smarterplan, and `scale`\n                        // is [Float] there but a plain Float in museum. Sending the smarterplan\n                        // shape to museum was rejected with \"The variables input contains a field\n                        // that is not defined for input object type 'CreateObject3DInput'\".\n                        //\n                        // The input therefore MIRRORS the source record instead of imposing a\n                        // shape: source and target live in the same deployment, so whatever the\n                        // source carries is exactly what the target accepts.\n                        const object3DInput: any = {\n                            path: copiedPath,\n                            // Tells the viewer how to interpret `path`. Dropping it turned an\n                            // S3-hosted model into a library reference on the copy, which the\n                            // viewer then tried to resolve against assets/ and failed to load.\n                            s3Bucket: !!rawSource.s3Bucket,\n                            name: rawSource.name,\n                            description: rawSource.description || \"\",\n                            spaceID: targetSpaceId,\n                            position: toFloatArray(rawSource.position, [0, 0, 0]),\n                            rotation: toFloatArray(rawSource.rotation, [0, 0, 0])\n                        };\n\n                        if ('viewFrustum' in rawSource) {\n                            object3DInput.viewFrustum = !!rawSource.viewFrustum;\n                        }\n\n                        // Scale keeps the source's own shape: a list stays a list, a scalar stays\n                        // a scalar. An absent scale is left unset rather than invented, so the copy\n                        // renders exactly like the original.\n                        if (Array.isArray(rawSource.scale)) {\n                            object3DInput.scale = toFloatArray(rawSource.scale, [1, 1, 1]);\n                        } else if (rawSource.scale !== null && rawSource.scale !== undefined) {\n                            const scalarScale = parseFloat(rawSource.scale);\n                            object3DInput.scale = Number.isNaN(scalarScale) ? 1 : scalarScale;\n                        }\n\n                        const createdObj = await this.object3DService.create(object3DInput);\n\n                        if (createdObj && createdObj.id) {\n                            elementIds[sourceObj.id] = createdObj.id;\n                        }\n\n                        for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {\n                            await this.createCopiedPoi(\n                                sourcePoi, createdObj.id,\n                                sourceNavPositions, targetNavPositions, transform\n                            );\n                        }\n                    }\n                } catch (itemError) {\n                    // The backend can deny creation of this whole model to the signed-in account\n                    // (in MUSEUM, Object3D only grants get/list to userPools). The denial is not\n                    // per-item, so every remaining object would fail identically: report it once,\n                    // as a permission problem rather than a copy error, and stop the phase instead\n                    // of firing one doomed mutation per object.\n                    if (this.isUnauthorized(itemError)) {\n                        const remaining = sourceObjects3D.length - i;\n                        console.warn(`[MatterportTagCopyService] Not allowed to create 3D objects in the target space, skipping ${remaining} of them.`, itemError);\n                        errorCount++;\n                        this.logItemError('errorObjects3dNotAllowed', { count: remaining });\n\n                        processedOverall += remaining;\n                        emitProgress('objects3d', sourceObjects3D.length, sourceObjects3D.length);\n                        this.setStepProgress('objects3d', 'objects3d', 100);\n                        break;\n                    }\n\n                    console.error(`Error copying object3D \"${sourceObj?.name}\":`, itemError);\n                    errorCount++;\n                    this.logCopyItemError(itemError, 'errorObject3d', sourceObj?.name || sourceObj?.id);\n                }\n\n                processedOverall++;\n                emitProgress('objects3d', i + 1, sourceObjects3D.length);\n                const pct = sourceObjects3D.length > 0 ? Math.round(((i + 1) / sourceObjects3D.length) * 100) : 100;\n                this.setStepProgress('objects3d', 'objects3d', pct);\n            }\n\n            // FEATURES — the \"POI\" of the MUSEUM module: its own record (title, index, locale,\n            // keywords), its media set (one Comment per image/video/audio/document/link/text)\n            // and its POI record (the pastille: icon, tag description, cover image).\n            // Everything is copied here, files physically duplicated in S3 first.\n            for (let i = 0; i < sourceFeatures.length; i++) {\n                const sourceObj = sourceFeatures[i];\n\n                try {\n                    const existingMatch = this.findExisting(\n                        sourceObj as any, targetFeatures as any,\n                        (f: any) => [f.title, f.description]\n                    );\n\n                    if (!existingMatch) {\n                        const rawSource = sourceObj as any;\n\n                        // Resolved just before the write: a keyword is only created in the target\n                        // space when the POI carrying it is about to be created.\n                        const resolvedHashtags = await this.resolveHashtagIds(rawSource.hashtags, targetSpaceId);\n\n                        const featureInput: any = {\n                            title: rawSource.title,\n                            shortDescription: rawSource.shortDescription,\n                            level: rawSource.level,\n                            type: rawSource.type,\n                            // `index` drives the ordering of the POI in the space's list, in the\n                            // lateral menu and in the guided tour. Dropping it forced a full manual\n                            // renumbering of every copied POI.\n                            index: rawSource.index ?? null,\n                            // Missions are per-space: source mission ids mean nothing in the target\n                            // space, so an archive list carried over would hide POIs from nobody\n                            // while looking like real data. Reset instead.\n                            archivedForMissionID: null,\n                            stripeProductID: rawSource.stripeProductID || null,\n                            stripePriceID: rawSource.stripePriceID || null,\n                            bookingPriceMetadata: rawSource.bookingPriceMetadata || null,\n                            locale: rawSource.locale || null,\n                            // Hashtags are space-scoped records: the ids must be translated to the\n                            // equivalent hashtags of the target space (created on demand).\n                            hashtags: resolvedHashtags,\n                            description: rawSource.description || null,\n                            // Reused unchanged in the same organisation, matched by name\n                            // across two — see resolveDomainID().\n                            domainID: this.resolveDomainID(rawSource.domainID),\n                            spaceID: targetSpaceId,\n                            ownerMissionID: targetMissionId\n                        };\n\n                        const createdObj = await this.featureService.createFeature(featureInput);\n\n                        if (createdObj && createdObj.id) {\n                            elementIds[sourceObj.id] = createdObj.id;\n                            // The feature exists: its keywords are now genuinely referenced and\n                            // must survive the end-of-run cleanup.\n                            this.markHashtagsUsed(resolvedHashtags);\n                        }\n\n                        if (createdObj) {\n                            // Read the media set through its own paginated query: the `comments`\n                            // connection embedded in FeaturesBySpace is capped at 100 items and its\n                            // nextToken was never followed, so rich POIs lost attachments silently.\n                            let sourceComments: Comment[] = [];\n                            try {\n                                sourceComments = await this.commentService.getAllCommentsForFeature(sourceObj.id);\n                            } catch (commentsFetchError) {\n                                console.warn(`Falling back to the embedded comment list for feature \"${rawSource.title}\":`, commentsFetchError);\n                                sourceComments = (sourceObj.comments?.items || []).filter(c => !!c) as Comment[];\n                            }\n\n                            for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {\n                                try {\n                                    const created = await this.copyCommentForFeature(\n                                        sourceComment, createdObj.id, targetSpaceId\n                                    );\n                                    if (created?.id && (sourceComment as any).id) {\n                                        this.commentIds.set((sourceComment as any).id, created.id);\n                                    }\n                                } catch (attachmentError) {\n                                    console.error(`Error copying attachment \"${sourceComment?.title}\" for feature \"${sourceObj?.title}\":`, attachmentError);\n                                    errorCount++;\n                                    this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || (sourceComment as any)?.id, {\n                                        feature: rawSource.title || sourceObj.id\n                                    });\n                                }\n                            }\n\n                            // Every POI of the feature, not only the first one: a feature may be\n                            // pinned at several places, and only this phase knows the new element id.\n                            const sourceFeaturePois = (sourceObj.pois?.items || []).filter(p => !!p);\n                            for (const sourcePoi of sourceFeaturePois) {\n                                await this.createCopiedPoi(\n                                    sourcePoi, createdObj.id,\n                                    sourceNavPositions, targetNavPositions, transform\n                                );\n                            }\n                        }\n                    } else {\n                        // Same reasoning as the EQUIPMENTS phase (see the comment there): a\n                        // feature matching this one already exists in the target space, most\n                        // likely from an earlier, incomplete run. Fill in whatever identity\n                        // field it is missing rather than leaving it untouched.\n                        elementIds[sourceObj.id] = existingMatch.id;\n                        const healedFields = await this.healFeatureIdentity(sourceObj as any, existingMatch as any);\n                        if (healedFields.length > 0) {\n                            healedCount++;\n                            this.logHealedItem('featureHealed', (sourceObj as any)?.title || sourceObj?.id, healedFields);\n                        }\n                    }\n                } catch (itemError) {\n                    console.error(`Error copying feature \"${sourceObj?.title}\" (id: ${sourceObj?.id}):`, itemError);\n                    errorCount++;\n                    this.logCopyItemError(itemError, 'errorFeature', sourceObj?.title || sourceObj?.id);\n                }\n\n                processedOverall++;\n                emitProgress('features', i + 1, sourceFeatures.length);\n                const pct = sourceFeatures.length > 0 ? Math.round(((i + 1) / sourceFeatures.length) * 100) : 100;\n                this.setStepProgress('features', 'features', pct);\n            }\n\n            // MEASUREMENTS (IMMO only — a Comment + a positional-only POI, no rotation;\n            // the screenshot file is physically duplicated in S3 first)\n            if (this.spModule == SpModule.IMMO) {\n                for (let i = 0; i < sourceMeasurements.length; i++) {\n                    const sourceMeasurement = sourceMeasurements[i];\n\n                    try {\n                        const existsInTarget = targetMeasurements.some(\n                            tm => tm.comment.title === sourceMeasurement.comment.title\n                        );\n\n                        if (!existsInTarget) {\n                            const rawComment = sourceMeasurement.comment as any;\n\n                            let copiedAnnexe: string | null = null;\n                            if (rawComment.annexe) {\n                                copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `measurement screenshot \"${rawComment.title}\"`);\n                            }\n\n                            const commentInput: any = {\n                                title: rawComment.title,\n                                description: rawComment.description ?? null,\n                                metadata: rawComment.metadata ?? null,\n                                type: CommentType.MEASURE,\n                                dimensions: rawComment.dimensions || null,\n                                annexe: copiedAnnexe,\n                                spaceID: targetSpaceId,\n                                // Same authorship rule as every other copied comment — see\n                                // resolveCommentOwnerID().\n                                ownerID: this.resolveCommentOwnerID(rawComment.ownerID),\n                            };\n\n                            const createdComment: Comment = await this.commentService.createComment(commentInput);\n\n                            if (createdComment && (createdComment as any).id && rawComment.id) {\n                                this.commentIds.set(rawComment.id, (createdComment as any).id);\n                            }\n\n                            if (createdComment && sourceMeasurement.poi) {\n                                const targetSweepId = this.findClosestTargetSweepId(\n                                    sourceMeasurement.poi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\n                                );\n                                const adjustedPosition = this.getAdjustedPositionOnly(sourceMeasurement.poi.coordinate, transform);\n                                const poiInput: POI = {\n                                    coordinate: JSON.stringify(adjustedPosition),\n                                    type: PoiType.MEASURE,\n                                    elementID: (createdComment as any).id,\n                                    // Same treatment as any other POI: the source's Matterport tag\n                                    // SID must not travel, and the stem normal has to be rotated.\n                                    metadata: this.getAdjustedPoiMetadata(sourceMeasurement.poi.metadata, transform),\n                                    matterportSweepID: targetSweepId\n                                };\n                                await this.poiService.createPOIForSpaceID(poiInput);\n                            }\n                        }\n                    } catch (itemError) {\n                        console.error(`Error copying measurement \"${sourceMeasurement?.comment?.title}\":`, itemError);\n                        errorCount++;\n                        this.logCopyItemError(itemError, 'errorMeasurement', sourceMeasurement?.comment?.title || sourceMeasurement?.id);\n                    }\n\n                    processedOverall++;\n                    emitProgress('measurements', i + 1, sourceMeasurements.length);\n                    const pct = sourceMeasurements.length > 0 ? Math.round(((i + 1) / sourceMeasurements.length) * 100) : 100;\n                    this.setStepProgress('measurements', 'measurements', pct);\n                }\n            }\n\n            // POIS — standalone ones only: every POI owned by an element was already created by\n            // that element's phase, with the element's NEW id.\n            //\n            // This phase runs LAST on purpose. It used to run third, before 3D objects, features\n            // and measurements existed in the target space, so `elementIds` and `commentIds` were\n            // still empty when it needed them: elementID stayed pointing at the source space and\n            // tagImageID (a reference to a Comment record) could never be resolved.\n            for (let i = 0; i < sourcePois.length; i++) {\n                const sourcePoi = sourcePois[i];\n\n                try {\n                    const existsInTarget = targetPois.some(\n                        tp => tp.coordinate === sourcePoi.coordinate && tp.tagDescription === sourcePoi.tagDescription\n                    );\n\n                    if (!existsInTarget) {\n                        const elementID = sourcePoi.elementID\n                            ? (elementIds[sourcePoi.elementID] || sourcePoi.elementID)\n                            : sourcePoi.elementID;\n\n                        await this.createCopiedPoi(\n                            sourcePoi, elementID,\n                            sourceNavPositions, targetNavPositions, transform\n                        );\n                    }\n                } catch (itemError) {\n                    console.error(`Error copying POI (sweep: ${sourcePoi?.matterportSweepID}):`, itemError);\n                    errorCount++;\n                    this.logCopyItemError(itemError, 'errorPoi', sourcePoi?.matterportSweepID, {\n                        sweep: sourcePoi?.matterportSweepID\n                    });\n                }\n\n                processedOverall++;\n                emitProgress('pois', i + 1, sourcePois.length);\n                const pct = sourcePois.length > 0 ? Math.round(((i + 1) / sourcePois.length) * 100) : 100;\n                this.setStepProgress('pois', 'pois', pct);\n            }\n\n            this.copyProgress$.next({\n                phase: 'done',\n                processedInPhase: 0, totalInPhase: 0,\n                processedOverall, totalOverall,\n                percent: 100, errorCount, healedCount\n            });\n            this.setStepLog('done', errorCount > 0\n                ? this.translate.instant('matterportCopy.doneWithErrors', { count: errorCount })\n                : this.translate.instant('matterportCopy.done'));\n            // Separate summary line, on top of (not instead of) the done/doneWithErrors one\n            // above: healing is orthogonal to success/failure, an already-complete run can\n            // still have repaired items left over from an earlier, incomplete attempt.\n            if (healedCount > 0) {\n                this.setStepLog('healedSummary', this.translate.instant('matterportCopy.healedSummary', { count: healedCount }));\n            }\n\n            return true;\n        } catch (error) {\n            console.error('Error copying POIs:', error);\n            this.appendErrorLog(this.translate.instant('matterportCopy.errorGeneral', { error: toErrorMessage(error) }));\n            this.copyProgress$.next(null);\n            return false;\n        } finally {\n            // Every exit path — success, partial success, or general failure — gives back the\n            // keywords this run created but no copied POI ended up using. Placed in `finally`\n            // so an exception thrown mid-copy cannot leave them behind either.\n            await this.cleanupUnusedCreatedHashtags();\n        }\n    }\n\n    /**\n     * Serialises the current copy log (step lines as last emitted, plus every error and\n     * healed-item notice) to a plain-text file and triggers a browser download — wired to a\n     * \"download log\" button in the copy UI, so an operator can keep or share the full report\n     * of a run rather than only the ~200px scrollable panel showing it.\n     */\n    downloadLog(filename?: string): void {\n        const text = this.log.map(entry => entry.text).join('\\n');\n        const defaultName = `matterport-copy-log-${new Date().toISOString().replace(/[:.]/g, '-')}.txt`;\n        downloadBlob(new Blob([text], { type: 'text/plain;charset=utf-8' }), filename || defaultName);\n    }\n\n    //\n    // ---------- Progress / log helpers ----------\n    //\n\n    /** Adds or updates a step line (identified by stepId) with new text, then republishes the log. */\n    private setStepLog(stepId: string, text: string) {\n        const existingIndex = this.log.findIndex(e => e.type === 'step' && e.id === stepId);\n        const entry: CopyLogEntry = { id: stepId, type: 'step', text };\n        if (existingIndex >= 0) {\n            this.log[existingIndex] = entry;\n        } else {\n            this.log.push(entry);\n        }\n        this.copyLog$.next([...this.log]);\n    }\n\n    /** Appends a new, permanent log line (never overwritten), then republishes the log. */\n    private appendErrorLog(text: string) {\n        this.logSeq++;\n        this.log.push({ id: `error-${this.logSeq}`, type: 'error', text });\n        this.copyLog$.next([...this.log]);\n    }\n\n    /** Appends a permanent log line for an item that was repaired rather than newly\n     *  created — see healEquipmentIdentity() and its ticket/feature equivalents. */\n    private appendHealedLog(text: string) {\n        this.logSeq++;\n        this.log.push({ id: `healed-${this.logSeq}`, type: 'healed', text });\n        this.copyLog$.next([...this.log]);\n    }\n\n    /** Resets the log for a new run. */\n    private resetLog() {\n        this.log = [];\n        this.logSeq = 0;\n        this.copyLog$.next([]);\n    }\n\n    /** Clears every id map carried over from a previous run. The service is a root-level\n     *  singleton, so leftover mappings would silently link a new copy to records created\n     *  during the previous one. */\n    private resetRunState(targetSpaceId: string) {\n        this.elementIds = {};\n        this.commentIds = new Map();\n        this.sourceHashtagNames = new Map();\n        this.targetHashtagIdsByName = new Map();\n        this.createdHashtagIds = new Set();\n        this.usedHashtagIds = new Set();\n        this.handledElementIds = new Set();\n        this.sourceMissionUserIds = new Map();\n        this.targetMissionIdsByUserId = new Map();\n        this.domainsById = new Map();\n        this.targetVisibleDomainOrgIds = new Set();\n        this.targetDomainIdsByTypeAndName = new Map();\n        this.targetSpaceId = targetSpaceId;\n    }\n\n    /** Builds and sets a step's log line as \"<translated label>: <percent>%\", no step numbering. */\n    private setStepProgress(stepId: string, translationKey: string, percent: number) {\n        const label = this.translate.instant(`matterportCopy.${translationKey}`);\n        this.setStepLog(stepId, `${label}: ${percent}%`);\n    }\n\n    /** Logs a translated, parameterized error line for a single failed item. */\n    private logItemError(translationKey: string, params: Record<string, any>) {\n        const text = this.translate.instant(`matterportCopy.${translationKey}`, params);\n        this.appendErrorLog(text);\n    }\n\n    /** Logs a translated line for an item that already existed in the target space and had\n     *  its missing identity fields filled in, so the operator can tell it apart from a\n     *  freshly created item in the copy report. */\n    private logHealedItem(translationKey: string, itemLabel: string, healedFields: string[]): void {\n        const text = this.translate.instant(`matterportCopy.${translationKey}`, {\n            name: itemLabel,\n            fields: healedFields.join(', ')\n        });\n        this.appendHealedLog(text);\n    }\n\n    /** Logs an item-level error, using a specific \"missing file / orphaned reference\"\n     *  translation key when the cause is a MissingS3FileError, and the generic per-type\n     *  key otherwise. Keeps the copy log readable: a missing file is not a bug to\n     *  investigate the same way a network/permission error is.\n     *  `extraParams` carries the placeholders a few keys need on top of {{name}}/{{error}}\n     *  (e.g. errorFeatureAttachment's {{feature}}, errorPoi's {{sweep}}), which used to be\n     *  rendered as raw \"{{feature}}\" text in the log. */\n    private logCopyItemError(\n        error: unknown,\n        genericKey: string,\n        itemLabel: string,\n        extraParams: Record<string, any> = {}\n    ) {\n        if (error instanceof MissingS3FileError) {\n            this.logItemError('errorMissingS3FileSkipped', {\n                ...extraParams,\n                name: itemLabel,\n                file: error.sourceKey\n            });\n        } else {\n            this.logItemError(genericKey, { ...extraParams, name: itemLabel, error: toErrorMessage(error) });\n        }\n    }\n\n    /**\n     * Null-safe equivalent of FeatureService.isArchived(): true when the operator has archived\n     * this feature on that space. \"No mission on the space\" answers false (nothing archived)\n     * instead of throwing, which is what made a copy from a space the operator is not a member\n     * of fail outright.\n     */\n    private isArchivedForOperator(feature: Feature, spaceId: string): boolean {\n        const archivedFor = feature?.archivedForMissionID;\n        if (!archivedFor || archivedFor.length === 0) {\n            return false;\n        }\n        const mission = this.userService.currentMission(spaceId);\n        return mission?.id ? archivedFor.includes(mission.id) : false;\n    }\n\n    //\n    // ---------- Cross-space reference remapping ----------\n    //\n\n    /** Normalised lookup key for a domain: type disambiguates same-named domains used for\n     *  different purposes (equipment vs. ticket vs. feature categories, ...). */\n    private domainKey(type: any, name: string): string {\n        return `${type || ''}::${(name || '').trim().toLowerCase()}`;\n    }\n\n    /**\n     * READ-ONLY indexing of every domain either operator's Mission can see. Creates\n     * nothing — unlike hashtags, a domain is a business taxonomy entry an operator manages\n     * deliberately; this tool only ever reuses an EXISTING equivalent, it never invents one.\n     *\n     * Visibility is keyed to `currentMission(spaceId).organisationID` /\n     * `.orderedOrganisationID` for EACH space — exactly what\n     * `DomainService.getDomainsForOrgForType()` uses to populate the category dropdown on\n     * the equipment/ticket/feature edit forms (see form-equipment.component.ts,\n     * batch-edit-equipment.component.ts, form-feature.component.ts). Comparing the spaces'\n     * OWN `organisationID` instead — the previous approach — missed every domain reachable\n     * only through the operator's `orderedOrganisationID` (set when a mission is created \"on\n     * behalf of\" another organisation — see form-mission.component.ts), which is exactly how\n     * a domain ends up visible on two spaces that belong to different organisations.\n     */\n    private async loadDomainIndex(sourceSpaceId: string, targetSpaceId: string): Promise<void> {\n        const sourceMission = this.userService.currentMission(sourceSpaceId);\n        const targetMission = this.userService.currentMission(targetSpaceId);\n\n        const sourceOrgIds = [sourceMission?.organisationID, sourceMission?.orderedOrganisationID]\n            .filter((id): id is string => !!id);\n        const targetOrgIds = [targetMission?.organisationID, targetMission?.orderedOrganisationID]\n            .filter((id): id is string => !!id);\n        this.targetVisibleDomainOrgIds = new Set(targetOrgIds);\n\n        const allOrgIds = Array.from(new Set([...sourceOrgIds, ...targetOrgIds]));\n        if (allOrgIds.length === 0) {\n            // The operator has no mission on either space — nothing to resolve against;\n            // every domainID will be dropped, same as an unresolvable lookup elsewhere.\n            return;\n        }\n\n        try {\n            const domainLists = await Promise.all(\n                allOrgIds.map(orgId => this.domainService.getAllGenericDomainsAndForOrganisation(orgId))\n            );\n            for (const list of domainLists) {\n                for (const domain of list || []) {\n                    if (domain?.id) {\n                        this.domainsById.set(domain.id, domain);\n                    }\n                }\n            }\n        } catch (error) {\n            console.warn('[MatterportTagCopyService] Could not read the domains, cross-organisation categories will be dropped:', error);\n            return;\n        }\n\n        for (const domain of this.domainsById.values()) {\n            const visibleToTarget = !domain.organisationID || this.targetVisibleDomainOrgIds.has(domain.organisationID);\n            if (visibleToTarget && domain.name) {\n                this.targetDomainIdsByTypeAndName.set(this.domainKey(domain.type, domain.name), domain.id);\n            }\n        }\n    }\n\n    /**\n     * Resolves a source domainID (equipment/ticket/feature/POI category) for use in the\n     * target space.\n     *\n     *  - generic domain (no organisationID of its own — a shared taxonomy entry, e.g. a\n     *    standard category created by the platform): reused unchanged, valid everywhere.\n     *  - the domain's own organisationID is already one the TARGET operator's mission can\n     *    see (its organisationID, or its orderedOrganisationID): reused unchanged too — the\n     *    id is directly selectable in the target space's own dropdown as-is.\n     *  - otherwise: matched by (type, name) against the domains visible to the TARGET\n     *    operator (loadDomainIndex()); dropped when no equivalent exists there.\n     */\n    private resolveDomainID(sourceDomainId: string | null | undefined): string | null {\n        if (!sourceDomainId) {\n            return null;\n        }\n\n        const domain = this.domainsById.get(sourceDomainId);\n        if (!domain) {\n            // Not visible to either operator's mission (lookup failed, or it belongs to\n            // neither) — unchanged, safest to drop.\n            return null;\n        }\n        if (!domain.organisationID || this.targetVisibleDomainOrgIds.has(domain.organisationID)) {\n            return sourceDomainId;\n        }\n        return this.targetDomainIdsByTypeAndName.get(this.domainKey(domain.type, domain.name)) ?? null;\n    }\n\n    /** Normalised lookup key for a hashtag name, so \"Moyen Âge\" and \"moyen âge \" match. */\n    private hashtagKey(name: string): string {\n        return name.trim().toLowerCase();\n    }\n\n    /**\n     * READ-ONLY indexing of both spaces' hashtags. Creates nothing.\n     *\n     * `Feature.hashtags` stores Hashtag *ids*, and a Hashtag is a per-space record, so the\n     * ids have to be translated by name. The translation table is built here; the missing\n     * keywords are created later, one at a time, only when a POI that actually uses them is\n     * about to be written (see resolveHashtagIds()).\n     */\n    private async loadHashtagIndex(sourceSpaceId: string, targetSpaceId: string): Promise<void> {\n        let sourceHashtags: Hashtag[] = [];\n        let targetHashtags: Hashtag[] = [];\n\n        try {\n            [sourceHashtags, targetHashtags] = await Promise.all([\n                this.hashtagService.listHashtagsForSpace(sourceSpaceId),\n                this.hashtagService.listHashtagsForSpace(targetSpaceId)\n            ]);\n        } catch (error) {\n            console.warn('[MatterportTagCopyService] Could not read the hashtags, keywords will be dropped:', error);\n            return;\n        }\n\n        for (const hashtag of sourceHashtags || []) {\n            if (hashtag?.id && hashtag.name) {\n                this.sourceHashtagNames.set(hashtag.id, hashtag.name);\n            }\n        }\n        for (const hashtag of targetHashtags || []) {\n            if (hashtag?.id && hashtag.name) {\n                this.targetHashtagIdsByName.set(this.hashtagKey(hashtag.name), hashtag.id);\n            }\n        }\n    }\n\n    /**\n     * Translates one feature's hashtag ids into target-space ids, creating on the fly the\n     * keywords the target space does not have yet.\n     *\n     * Creation is LAZY on purpose. Doing it up front, for the whole source vocabulary, meant\n     * that a copy which failed or was closed halfway left behind keywords no POI referenced —\n     * pollution the operator had to clean up by hand. Here a keyword is only ever written\n     * when a POI that carries it is about to be created, so an interrupted copy stops\n     * creating keywords at the same POI it stops creating content.\n     *\n     * The residual window (keyword created, then createFeature fails) is closed by\n     * markHashtagsUsed() + cleanupUnusedCreatedHashtags().\n     *\n     * A keyword that can neither be found nor created is dropped rather than left as a\n     * dangling id.\n     */\n    private async resolveHashtagIds(\n        sourceHashtagIds: Array<string | null> | null | undefined,\n        targetSpaceId: string\n    ): Promise<string[] | null> {\n        if (!sourceHashtagIds || sourceHashtagIds.length === 0) {\n            return null;\n        }\n\n        const resolved: string[] = [];\n\n        for (const sourceId of sourceHashtagIds) {\n            if (!sourceId) {\n                continue;\n            }\n            const name = this.sourceHashtagNames.get(sourceId);\n            if (!name) {\n                // the source id points at a hashtag that no longer exists — nothing to carry over\n                continue;\n            }\n\n            const key = this.hashtagKey(name);\n            let targetId = this.targetHashtagIdsByName.get(key);\n\n            if (!targetId) {\n                try {\n                    const created = await this.hashtagService.createHashtagForSpace(name, targetSpaceId);\n                    targetId = created?.id;\n                    if (targetId) {\n                        this.targetHashtagIdsByName.set(key, targetId);\n                        this.createdHashtagIds.add(targetId);\n                    }\n                } catch (error) {\n                    console.warn(`[MatterportTagCopyService] Could not create the hashtag \"${name}\" in the target space:`, error);\n                    continue;\n                }\n            }\n\n            if (targetId && !resolved.includes(targetId)) {\n                resolved.push(targetId);\n            }\n        }\n\n        return resolved.length > 0 ? resolved : null;\n    }\n\n    /**\n     * READ-ONLY indexing of both spaces' missions.\n     *\n     * A Mission is scoped to one space (it pairs a userID with a spaceID), so the id a\n     * source comment's `ownerID` points at never designates anyone in the target space.\n     * This builds the two lookup tables resolveCommentOwnerID() needs to translate it:\n     * which user a source Mission id belongs to, and which Mission (if any) that same\n     * user already holds in the target space.\n     */\n    private async loadMissionIndex(sourceSpaceId: string, targetSpaceId: string): Promise<void> {\n        let sourceMissions: Mission[] = [];\n        let targetMissions: Mission[] = [];\n\n        try {\n            [sourceMissions, targetMissions] = await Promise.all([\n                this.missionService.getAllMissionsForSpace(sourceSpaceId),\n                this.missionService.getAllMissionsForSpace(targetSpaceId)\n            ]);\n        } catch (error) {\n            console.warn('[MatterportTagCopyService] Could not read the missions, comment authorship will be dropped:', error);\n            return;\n        }\n\n        for (const mission of sourceMissions || []) {\n            if (mission?.id && mission.userID) {\n                this.sourceMissionUserIds.set(mission.id, mission.userID);\n            }\n        }\n        for (const mission of targetMissions || []) {\n            if (mission?.id && mission.userID && !this.targetMissionIdsByUserId.has(mission.userID)) {\n                this.targetMissionIdsByUserId.set(mission.userID, mission.id);\n            }\n        }\n    }\n\n    /**\n     * Translates a source comment's `ownerID` (a per-space Mission id) into the Mission of\n     * the SAME user in the target space, so the copy keeps crediting its real author.\n     *\n     * Substituting the current operator's mission — the way `ownerMissionID` legitimately\n     * does for tickets/equipment/features, which really do change owner on a copy — would\n     * misattribute every comment to whoever ran the copy instead of who actually wrote it.\n     *\n     * When the original author has no mission in the target space (never granted access\n     * there), the comment is left with no owner rather than a wrong one: an absent author\n     * is honest, a misattributed one is not.\n     */\n    private resolveCommentOwnerID(sourceOwnerID: string | null | undefined): string | null {\n        if (!sourceOwnerID) {\n            return null;\n        }\n        const userID = this.sourceMissionUserIds.get(sourceOwnerID);\n        if (!userID) {\n            return null;\n        }\n        return this.targetMissionIdsByUserId.get(userID) ?? null;\n    }\n\n    /** Records that these hashtags are now referenced by a feature that really exists, so\n     *  the end-of-run cleanup leaves them alone. */\n    private markHashtagsUsed(hashtagIds: string[] | null): void {\n        for (const id of hashtagIds || []) {\n            this.usedHashtagIds.add(id);\n        }\n    }\n\n    /**\n     * Deletes the hashtags this run created that no copied POI ended up referencing.\n     *\n     * Runs on every exit path — success, general failure, or exception — so the target space\n     * never keeps keywords that came from an aborted copy. Only ids created by THIS run are\n     * ever considered: a pre-existing keyword of the target space is never touched, even if\n     * no copied POI uses it.\n     */\n    private async cleanupUnusedCreatedHashtags(): Promise<void> {\n        const orphans = [...this.createdHashtagIds].filter(id => !this.usedHashtagIds.has(id));\n        if (orphans.length === 0) {\n            return;\n        }\n\n        console.log(`[MatterportTagCopyService] Removing ${orphans.length} keyword(s) created but left unused by this copy.`);\n\n        for (const hashtagId of orphans) {\n            try {\n                await this.hashtagService.deleteHashtagById(hashtagId);\n                this.createdHashtagIds.delete(hashtagId);\n            } catch (error) {\n                // Cleanup is best-effort: a leftover keyword is harmless next to a failed copy,\n                // and must never be the reason the whole operation reports a failure.\n                console.warn(`[MatterportTagCopyService] Could not remove the unused keyword \"${hashtagId}\":`, error);\n            }\n        }\n    }\n\n    //\n    // ---------- Media content (Comments) ----------\n    //\n\n    /**\n     * Orders a feature's media set exactly the way the UI will read it back, and repairs\n     * the ordering key when the source data cannot express the user's intended order.\n     *\n     * The viewer sorts each media family on its own (`setImages`, `setVideos`, `setAudio`,\n     * `setDocuments`, ... all do `.sort((a, b) => a.index - b.index)`), so `index` only has\n     * to be consistent WITHIN a CommentType. The attachment form however defaults `index`\n     * to 1 for every new attachment, so a multi-image POI very often holds several images\n     * all sharing index 1 — or null. Sorting those is left to DynamoDB's arbitrary scan\n     * order, which is why the copy came out in a different order than the original.\n     *\n     * Strategy: sort deterministically (index, then creation date, then id — i.e. the\n     * upload order the user actually saw), and only rewrite the indices of a family when\n     * they are ambiguous (null or duplicated). A family whose indices are already unique\n     * is copied untouched, so a deliberate ordering is never overwritten.\n     */\n    private orderCommentsForCopy(comments: Comment[]): Comment[] {\n        const valid = (comments || []).filter(c => !!c);\n\n        const byType = new Map<string, Comment[]>();\n        for (const comment of valid) {\n            const key = (comment.type as string) || 'UNTYPED';\n            if (!byType.has(key)) {\n                byType.set(key, []);\n            }\n            byType.get(key).push(comment);\n        }\n\n        const ordered: Comment[] = [];\n\n        for (const family of byType.values()) {\n            family.sort((a, b) => {\n                const ai = this.orderingIndexOf(a);\n                const bi = this.orderingIndexOf(b);\n                if (ai !== bi) {\n                    return ai - bi;\n                }\n                const ad = this.creationTimeOf(a);\n                const bd = this.creationTimeOf(b);\n                if (ad !== bd) {\n                    return ad - bd;\n                }\n                return String((a as any).id || '').localeCompare(String((b as any).id || ''));\n            });\n\n            const indices = family.map(c => c.index);\n            const isAmbiguous = indices.some(i => i === null || i === undefined)\n                || new Set(indices).size !== indices.length;\n\n            family.forEach((comment, position) => {\n                (comment as any).__copyIndex = isAmbiguous ? position + 1 : comment.index;\n            });\n\n            ordered.push(...family);\n        }\n\n        return ordered;\n    }\n\n    /** Sort key for a comment's position; a missing index sorts last, not first. */\n    private orderingIndexOf(comment: Comment): number {\n        const index = comment?.index;\n        return index === null || index === undefined || Number.isNaN(Number(index))\n            ? Number.MAX_SAFE_INTEGER\n            : Number(index);\n    }\n\n    /** Creation timestamp of a comment, used as the tie-breaker: it reflects the order in\n     *  which the user uploaded the media, which is the order they saw. */\n    private creationTimeOf(comment: Comment): number {\n        const createdAt = (comment as any)?.createdAt;\n        if (!createdAt) {\n            return 0;\n        }\n        const time = new Date(createdAt).getTime();\n        return Number.isNaN(time) ? 0 : time;\n    }\n\n    /**\n     * Copies ONE media item (image, video, audio, document, text, link, embed, iframe...)\n     * of a feature, duplicating its file in S3 first when it has one.\n     *\n     * Every column of the Comment model is carried over. `description` and `metadata` were\n     * previously dropped, which emptied the captions of images/videos, the body of TEXT\n     * items — where the whole content lives, since a TEXT comment has no file — and any\n     * per-media settings stored in metadata.\n     */\n    private async copyCommentForFeature(\n        sourceComment: Comment,\n        targetFeatureId: string,\n        targetSpaceId: string\n    ): Promise<Comment> {\n        return this.copyComment(sourceComment, targetSpaceId, { featureID: targetFeatureId });\n    }\n\n    /** Same, for an attachment carried by a ticket rather than by a feature. */\n    private async copyCommentForTicket(\n        sourceComment: Comment,\n        targetTicketId: string,\n        targetSpaceId: string\n    ): Promise<Comment> {\n        return this.copyComment(sourceComment, targetSpaceId, { ticketID: targetTicketId });\n    }\n\n    /** Shared body of the two above: `owner` carries whichever foreign key links the copy back\n     *  to its new parent, everything else is identical. */\n    private async copyComment(\n        sourceComment: Comment,\n        targetSpaceId: string,\n        owner: { featureID?: string; ticketID?: string }\n    ): Promise<Comment> {\n        const rawComment = sourceComment as any;\n\n        let copiedAnnexe: string | null = null;\n        if (rawComment.annexe) {\n            copiedAnnexe = await this.copyS3KeyIfPresent(rawComment.annexe, `attachment \"${rawComment.title}\"`);\n        }\n\n        const commentInput: any = {\n            title: rawComment.title,\n            description: rawComment.description ?? null,\n            metadata: rawComment.metadata ?? null,\n            type: rawComment.type,\n            annexe: copiedAnnexe,\n            externalLink: rawComment.externalLink || null,\n            dimensions: rawComment.dimensions || null,\n            index: rawComment.__copyIndex ?? rawComment.index ?? null,\n            shownInTag: rawComment.shownInTag,\n            isCoverImage: rawComment.isCoverImage,\n            spaceID: targetSpaceId,\n            // Keeps crediting the ORIGINAL author when they also have a mission in the\n            // target space, and leaves the comment un-owned otherwise — see\n            // resolveCommentOwnerID(). Never the current operator's own mission: that\n            // would silently reassign authorship to whoever happens to run the copy.\n            ownerID: this.resolveCommentOwnerID(rawComment.ownerID),\n            ...owner\n        };\n\n        return this.commentService.createComment(commentInput);\n    }\n\n    //\n    // ---------- POI creation ----------\n    //\n\n    /**\n     * Creates the target-space copy of a source POI, with EVERY column of the POI model.\n     *\n     * Single entry point for all phases: the element phases (ticket, equipment, 3D object,\n     * feature, measurement) used to build their POI inline with only 5 fields — coordinate,\n     * type, elementID, metadata, sweep — which is precisely how museum POIs lost their\n     * pastille: `tagDescription` (the popup text), `tagIcon` (the custom icon) and\n     * `tagImageID` (the pastille's image) never left the source space.\n     */\n    private async createCopiedPoi(\n        sourcePoi: POI,\n        elementID: string | null,\n        sourceNavPositions: Map<string, Vec3>,\n        targetNavPositions: Map<string, Vec3>,\n        transform: RigidTransform\n    ): Promise<POI> {\n        const raw = sourcePoi as any;\n\n        const targetSweepId = this.findClosestTargetSweepId(\n            sourcePoi.matterportSweepID, sourceNavPositions, targetNavPositions, transform\n        );\n        const adjustedCoordinate = this.getAdjustedCoordinates(sourcePoi.coordinate, transform);\n\n        const poiInput: any = {\n            coordinate: adjustedCoordinate === null || adjustedCoordinate === undefined\n                ? null\n                : JSON.stringify(adjustedCoordinate),\n            type: sourcePoi.type,\n            elementID: elementID ?? null,\n            matterportSweepID: targetSweepId,\n\n            // --- pastille (tag popup) ---\n            tagDescription: sourcePoi.tagDescription ?? null,\n            tagIcon: await this.duplicateTagIcon(sourcePoi.tagIcon),\n            tagImageID: this.resolveTagImageID(sourcePoi.tagImageID),\n\n            // --- rendering / visibility flags, carried over verbatim ---\n            specific: raw.specific ?? null,\n            private: raw.private ?? null,\n            global: raw.global ?? null,\n            level: raw.level ?? null,\n            role: raw.role ?? null,\n            category: raw.category ?? null,\n            domainID: this.resolveDomainID(raw.domainID),\n\n            // --- Matterport anchoring ---\n            metadata: this.getAdjustedPoiMetadata(sourcePoi.metadata, transform)\n        };\n\n        return this.poiService.createPOIForSpaceID(poiInput as POI);\n    }\n\n    /**\n     * Adapts a POI's `metadata` (see MattertagData.getMetadataString(): { icon, normal, sid })\n     * to the target space.\n     *\n     *  - `sid` is the id of the Mattertag inside the SOURCE Matterport model. Carried over,\n     *    the viewer tries to re-create the target's tag with an id belonging to another\n     *    model (\"already in use\"), so the pastille fails to attach. It is dropped: the\n     *    viewer then allocates a fresh sid on first render.\n     *  - `normal` is the stem direction. It is a direction, so only the rotation applies\n     *    (never the translation); without it, a copied pastille points into the wall\n     *    whenever the two models are not aligned on the same axis.\n     *  - `icon` and anything else is kept as-is.\n     */\n    private getAdjustedPoiMetadata(metadata: string | null | undefined, transform: RigidTransform): string | null {\n        if (!metadata) {\n            return metadata ?? null;\n        }\n        try {\n            const parsed = JSON.parse(metadata);\n            if (!parsed || typeof parsed !== 'object') {\n                return metadata;\n            }\n\n            if (parsed.normal\n                && typeof parsed.normal === 'object'\n                && typeof parsed.normal.x === 'number'\n                && typeof parsed.normal.y === 'number'\n                && typeof parsed.normal.z === 'number') {\n                parsed.normal = applyRigidTransformToDirection(parsed.normal, transform);\n            }\n\n            delete parsed.sid;\n\n            return JSON.stringify(parsed);\n        } catch {\n            // Not JSON, or unexpected shape — leave untouched rather than guess.\n            return metadata;\n        }\n    }\n\n    /**\n     * Resolves a POI's `tagImageID` — which the schema documents as a \"connection to\n     * comment.id\", i.e. the id of the Comment holding the image shown in the pastille.\n     *\n     * It is NOT an S3 key, so the previous \"does it contain a slash?\" heuristic never\n     * matched and the value travelled unchanged, leaving every copied pastille pointing at\n     * a Comment of the source space. It is now translated through the comment id map built\n     * while duplicating the media, and dropped when it cannot be resolved (the pastille\n     * then falls back to the feature's cover image instead of a broken reference).\n     */\n    private resolveTagImageID(tagImageID: string | null | undefined): string | null {\n        if (!tagImageID) {\n            return null;\n        }\n        return this.commentIds.get(tagImageID) ?? null;\n    }\n\n    //\n    // ---------- Duplicate detection ----------\n    //\n\n    /**\n     * Heuristic duplicate-detection: compares several identifying fields together rather than\n     * a single label, to reduce false positives when items share one of them. Returns the\n     * matched target item (or undefined) rather than a boolean, so the caller can act on the\n     * existing record — heal its missing fields — instead of only skipping it.\n     *\n     * The fields are supplied by the caller because the models do not agree on them. The\n     * previous version hard-coded `title`/`description`, which do not exist on Equipment at\n     * all: both sides read `undefined`, every equipment therefore \"matched\" every other one,\n     * and a target space holding a single equipment silently caused the whole equipment phase\n     * to copy nothing.\n     */\n    private findExisting<T>(\n        source: T,\n        targetList: T[],\n        identity: (item: T) => Array<string | null | undefined>\n    ): T | undefined {\n        const sourceKey = this.identityKey(identity(source));\n        return targetList.find(target => this.identityKey(identity(target)) === sourceKey);\n    }\n\n    /**\n     * Builds a patch of whichever fields in `fields` the existing target record is missing\n     * (`null`/`undefined`/empty array) but the source has, plus `domainID` when requested —\n     * domains are organisation-scoped everywhere in this file, so that one is only ever\n     * healed across the SAME organisation, exactly like at creation time.\n     *\n     * Never overwrites a field the target already carries a value for: a value entered by\n     * hand in the target space since an earlier, incomplete copy must not be clobbered by\n     * an older or different source value.\n     *\n     * Returns both the patch to send and the list of healed field names, so the caller can\n     * both perform the update and describe it in the copy log.\n     */\n    private buildHealPatch(\n        sourceObj: any,\n        existingTarget: any,\n        fields: string[],\n        includeDomain: boolean\n    ): { patch: any; healedFields: string[] } {\n        const patch: any = {};\n        const healedFields: string[] = [];\n\n        const fillIfMissing = (key: string, sourceValue: any) => {\n            const currentValue = existingTarget[key];\n            const isMissing = currentValue === null || currentValue === undefined\n                || (Array.isArray(currentValue) && currentValue.length === 0);\n            if (isMissing && sourceValue !== null && sourceValue !== undefined) {\n                patch[key] = sourceValue;\n                healedFields.push(key);\n            }\n        };\n\n        for (const field of fields) {\n            fillIfMissing(field, sourceObj[field]);\n        }\n        if (includeDomain && (existingTarget.domainID === null || existingTarget.domainID === undefined)) {\n            const resolvedDomainId = this.resolveDomainID(sourceObj.domainID);\n            if (resolvedDomainId) {\n                patch.domainID = resolvedDomainId;\n                healedFields.push('domainID');\n            }\n        }\n\n        return { patch, healedFields };\n    }\n\n    /**\n     * Fills in whichever identity field a PRE-EXISTING target equipment is missing but the\n     * source has — see the call site in the EQUIPMENTS phase for why re-running the copy\n     * has to be able to repair a previously-copied equipment, not just skip it again.\n     *\n     * A failed update is left to bubble up to the caller's existing per-item try/catch, the\n     * same as a failed creation — it gets the same visible error line, rather than a silent\n     * console warning.\n     *\n     * Returns the list of fields that were actually healed (empty if nothing was missing).\n     */\n    private async healEquipmentIdentity(sourceObj: any, existingTarget: any): Promise<string[]> {\n        const { patch, healedFields } = this.buildHealPatch(\n            sourceObj, existingTarget,\n            ['status', 'annotation', 'family', 'sku', 'manufacturer', 'installDate', 'warrantyEndDate', 'metadata', 'isCreatedByAI'],\n            true\n        );\n\n        if (!existingTarget.photo && sourceObj.photo) {\n            patch.photo = await this.copyS3KeyIfPresent(sourceObj.photo, `equipment photo \"${sourceObj.name}\"`);\n            healedFields.push('photo');\n        }\n\n        if (healedFields.length === 0) {\n            return healedFields;\n        }\n\n        patch.id = existingTarget.id;\n        await this.equipmentService.updateEquipment(patch);\n        return healedFields;\n    }\n\n    /**\n     * Same idea as healEquipmentIdentity(), for a pre-existing ticket. `title`/`description`\n     * are the pair findExisting() matched on to find this ticket in the first place, so they\n     * are never part of the heal — by construction, they already agree with the source.\n     */\n    private async healTicketIdentity(sourceObj: any, existingTarget: any): Promise<string[]> {\n        const { patch, healedFields } = this.buildHealPatch(\n            sourceObj, existingTarget,\n            ['friendlyLabel', 'status', 'type', 'priority', 'level', 'metadata', 'read', 'projectID', 'problemCode'],\n            true\n        );\n\n        if (healedFields.length === 0) {\n            return healedFields;\n        }\n\n        patch.id = existingTarget.id;\n        await this.ticketService.updateTicket(patch);\n        return healedFields;\n    }\n\n    /** Same idea, for a pre-existing feature. Keywords, media and POIs are not healed here\n     *  for the same reason notes/POIs are not healed on equipment — see healEquipmentIdentity(). */\n    private async healFeatureIdentity(sourceObj: any, existingTarget: any): Promise<string[]> {\n        const { patch, healedFields } = this.buildHealPatch(\n            sourceObj, existingTarget,\n            ['shortDescription', 'level', 'type', 'index', 'stripeProductID', 'stripePriceID', 'bookingPriceMetadata', 'locale'],\n            true\n        );\n\n        if (healedFields.length === 0) {\n            return healedFields;\n        }\n\n        patch.id = existingTarget.id;\n        await this.featureService.updateFeature(patch);\n        return healedFields;\n    }\n\n    /** Serialises the identifying fields unambiguously, so that [\"a\", \"b\"] and [\"ab\", \"\"]\n     *  can never produce the same key. */\n    private identityKey(parts: Array<string | null | undefined>): string {\n        return JSON.stringify(parts.map(part => part ?? ''));\n    }\n\n    //\n    // ---------- Sweep positions / rigid transform ----------\n    //\n\n    /**\n     * Fetches the position of every sweep in a space and returns it as a Map for O(1) lookup.\n     * Uses allSettled so a single failing sweep lookup doesn't abort the whole map —\n     * that sweep is simply absent from the resulting map (and skipped later).\n     */\n    private async buildNavigationPositionMap(spaceId: string, sweepIds: string[]): Promise<Map<string, Vec3>> {\n        const map = new Map<string, Vec3>();\n\n        const results = await Promise.allSettled(\n            sweepIds.map(async (sid) => {\n                const navs = await this.navigationService.getNavigationsForMatterportIDForSpace(sid, spaceId);\n                if (navs && navs.length > 0 && navs[0].position) {\n                    return { sid, position: JSON.parse(navs[0].position) as Vec3 };\n                }\n                return null;\n            })\n        );\n\n        for (const result of results) {\n            if (result.status === 'fulfilled' && result.value) {\n                map.set(result.value.sid, result.value.position);\n            } else if (result.status === 'rejected') {\n                console.warn('Failed to fetch a sweep position, skipping it:', result.reason);\n            }\n        }\n\n        return map;\n    }\n\n    /** Applies the rigid transform to a POI coordinate (position + orientation). */\n    private getAdjustedCoordinates(coordinate: string, transform: RigidTransform): any {\n        if (coordinate === \"null\") {\n            return null;\n        }\n        if (!coordinate || typeof coordinate !== 'string') {\n            return coordinate;\n        }\n\n        const parsed = JSON.parse(coordinate);\n        const rotatedPos = applyRigidTransformToPoint(\n            { x: parsed.x, y: parsed.y, z: parsed.z },\n            transform\n        );\n\n        return {\n            x: rotatedPos.x,\n            y: rotatedPos.y,\n            z: rotatedPos.z,\n            xRotation: parsed.xRotation,\n            yRotation: applyRigidTransformToYRotationDeg(parsed.yRotation, transform)\n        };\n    }\n\n    /**\n     * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,\n     * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored\n     * coordinate is a bare position (no orientation), unlike other POI types.\n     */\n    private getAdjustedPositionOnly(coordinate: string, transform: RigidTransform): any {\n        if (!coordinate || typeof coordinate !== 'string' || coordinate === 'null') {\n            return coordinate;\n        }\n        const parsed = JSON.parse(coordinate);\n        return applyRigidTransformToPoint({ x: parsed.x, y: parsed.y, z: parsed.z }, transform);\n    }\n\n    /**\n     * Finds the closest target sweep, comparing positions in the SAME coordinate frame.\n     * Pure in-memory lookup — no network call, thanks to the pre-built position maps.\n     */\n    private findClosestTargetSweepId(\n        sourceSweepID: string,\n        sourceNavPositions: Map<string, Vec3>,\n        targetNavPositions: Map<string, Vec3>,\n        transform: RigidTransform\n    ): string | null {\n        if (!sourceSweepID) return null;\n\n        const sourcePos = sourceNavPositions.get(sourceSweepID);\n        if (!sourcePos) return null;\n\n        const sourcePosInTargetFrame = applyRigidTransformToPoint(sourcePos, transform);\n\n        let closestSweepID: string | null = null;\n        let minDistance = Infinity;\n\n        for (const [targetSweepId, targetPos] of targetNavPositions.entries()) {\n            const dx = targetPos.x - sourcePosInTargetFrame.x;\n            const dy = targetPos.y - sourcePosInTargetFrame.y;\n            const dz = targetPos.z - sourcePosInTargetFrame.z;\n            const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);\n\n            if (dist < minDistance) {\n                minDistance = dist;\n                closestSweepID = targetSweepId;\n            }\n        }\n\n        return closestSweepID;\n    }\n\n    //\n    // ---------- S3 file duplication ----------\n    //\n\n    /** Generates a short random id, used to give each copied S3 file a fresh, collision-safe key. */\n    private generateShortId(): string {\n        return Math.random().toString(36).slice(2, 10);\n    }\n\n    /**\n     * Builds a new S3 key for a copied attachment and sanitizes the filename\n     * to prevent AWS Amplify SignatureDoesNotMatch errors.\n     * `folderOverride` re-homes the copy into another prefix — used for tag icons, which\n     * are stored per space (`icons-tags/<spaceId>/`) and must follow the target space.\n     */\n    private buildCopiedAttachmentKey(sourceAnnexe: string, folderOverride: string | null = null): string {\n        const lastSlash = sourceAnnexe.lastIndexOf('/');\n        const folder = folderOverride ?? sourceAnnexe.substring(0, lastSlash + 1);\n        let filename = sourceAnnexe.substring(lastSlash + 1);\n\n        // Strip a leading \"<8 hex chars>_\" id prefix if present\n        const prefixMatch = filename.match(/^[0-9a-fA-F-]{8}_(.+)$/);\n        if (prefixMatch) {\n            filename = prefixMatch[1];\n        }\n\n        // SANITIZATION: Replace spaces, parentheses, and accents with underscores\n        // Crucial to prevent Amplify's Storage.copy from failing the signature calculation\n        filename = filename.replace(/[^a-zA-Z0-9.\\-_]/g, '_');\n\n        const newPrefix = `${this.generateShortId()}_`;\n        return `${folder}${newPrefix}${filename}`;\n    }\n\n    /**\n     * Duplicates an S3 object if a key is present.\n     * - If the source file is genuinely missing from S3 (NoSuchKey / orphaned DB reference),\n     *   throws a MissingS3FileError so the caller can log a clear, specific message and\n     *   skip the whole item entirely, rather than creating a record with a broken file link.\n     * - Any other kind of failure (permissions, network, etc.) still throws a generic Error.\n     */\n    private async copyS3KeyIfPresent(\n        key: string | null | undefined,\n        contextLabel: string,\n        folderOverride: string | null = null\n    ): Promise<string | null> {\n        if (!key) {\n            return null;\n        }\n        const sourceKey = this.extractS3KeyFromValue(key);\n        const destKey = this.buildCopiedAttachmentKey(sourceKey, folderOverride);\n\n        // Log the source key to ensure it matches the real S3 object path\n        console.log(`[DEBUG] Attempting S3 copy from source: \"${sourceKey}\" to dest: \"${destKey}\"`);\n\n        try {\n            const copied = await copyFileInS3(sourceKey, destKey);\n            if (!copied) {\n                throw new MissingS3FileError(sourceKey, contextLabel);\n            }\n            return copied;\n        } catch (error: any) {\n            if (this.isMissingS3File(error)) {\n                console.warn(`[MatterportTagCopyService] Orphaned S3 reference, skipping item: \"${sourceKey}\" (${contextLabel})`);\n                throw new MissingS3FileError(sourceKey, contextLabel);\n            }\n\n            // Storage.copy() cannot handle a key holding a space, an accent or a parenthesis:\n            // it puts the key unencoded into `x-amz-copy-source`, which then disagrees with the\n            // signed request. Those files are perfectly readable — only that header is broken —\n            // so fall back to downloading and re-uploading them.\n            if (this.isSignatureMismatch(error)) {\n                console.warn(`[MatterportTagCopyService] Storage.copy() signature mismatch on \"${sourceKey}\", falling back to download + re-upload.`);\n                try {\n                    const copied = await copyFileInS3ViaDownload(sourceKey, destKey);\n                    if (!copied) {\n                        throw new MissingS3FileError(sourceKey, contextLabel);\n                    }\n                    return copied;\n                } catch (fallbackError: any) {\n                    if (this.isMissingS3File(fallbackError)) {\n                        throw new MissingS3FileError(sourceKey, contextLabel);\n                    }\n                    throw fallbackError;\n                }\n            }\n\n            throw error;\n        }\n    }\n\n    /** True when the failure means the source object simply is not on S3 (orphaned reference). */\n    private isMissingS3File(error: any): boolean {\n        return error instanceof MissingS3FileError\n            || error?.code === 'NoSuchKey'\n            || error?.name === 'NoSuchKey'\n            || /NoSuchKey|does not exist|NotFound/i.test(toErrorMessage(error));\n    }\n\n    /** True when AppSync refused the operation for lack of permission, as opposed to failing it.\n     *  Nothing can be retried or worked around client-side: the account simply is not allowed\n     *  to write that model, which is a backend authorisation rule (@auth) to change. */\n    private isUnauthorized(error: any): boolean {\n        const message = toErrorMessage(error);\n        return error?.errorType === 'Unauthorized'\n            || /Unauthorized|Not Authorized to access/i.test(message);\n    }\n\n    /** True for the SigV4 mismatch Storage.copy() raises on keys with special characters. */\n    private isSignatureMismatch(error: any): boolean {\n        return error?.code === 'SignatureDoesNotMatch'\n            || error?.name === 'SignatureDoesNotMatch'\n            || /signature we calculated does not match|SignatureDoesNotMatch/i.test(toErrorMessage(error));\n    }\n\n    /**\n     * Duplicates the file referenced by a POI's tagIcon (a JSON string shaped like\n     * { src, opacity }, per form-feature.component.ts).\n     *\n     * Two behaviours matter here:\n     *  - the copy is re-homed under the TARGET space's icon folder\n     *    (`icons-tags/<targetSpaceId>/`, the layout form-feature.component.ts uploads to).\n     *    Keeping the source folder produced a target space whose icons all lived under\n     *    another space's prefix, so cleaning up the source space broke the copy's icons.\n     *  - a missing icon file is NOT fatal. It used to bubble up as a MissingS3FileError and\n     *    abort the whole POI — losing the pastille, its text and its media because of a\n     *    decorative file. The POI is now created with the icon reference dropped, which\n     *    renders the module's default icon, and a log line reports it.\n     */\n    private async duplicateTagIcon(tagIconRaw: string | null | undefined): Promise<string | null | undefined> {\n        if (!tagIconRaw) {\n            return tagIconRaw ?? null;\n        }\n\n        let parsed: any;\n        try {\n            parsed = JSON.parse(tagIconRaw);\n        } catch {\n            // Not JSON — leave untouched rather than guess.\n            return tagIconRaw;\n        }\n\n        if (!parsed || typeof parsed !== 'object' || !parsed.src) {\n            return tagIconRaw;\n        }\n\n        try {\n            parsed.src = await this.copyS3KeyIfPresent(\n                parsed.src, 'tag icon', this.buildTargetIconFolder()\n            );\n        } catch (iconError) {\n            if (!(iconError instanceof MissingS3FileError)) {\n                // A real failure (permissions, network, ...) still aborts the POI: it means\n                // the copy cannot be trusted, unlike a file that is simply already gone.\n                throw iconError;\n            }\n            console.warn(`[MatterportTagCopyService] Tag icon missing on S3, falling back to the default icon: \"${iconError.sourceKey}\"`);\n            this.logItemError('warningTagIconMissing', { file: iconError.sourceKey });\n            delete parsed.src;\n        }\n\n        return JSON.stringify(parsed);\n    }\n\n    /** Icon folder of the space being copied into, matching what the feature form uploads to. */\n    private buildTargetIconFolder(): string | null {\n        return this.targetSpaceId ? `icons-tags/${this.targetSpaceId}/` : null;\n    }\n\n    /**\n     * Extracts and normalizes the raw S3 key from a stored value (which may be a full URL\n     * or already a raw key).\n     * IMPORTANT: this must return the RAW (decoded, non URL-encoded) key. Amplify's\n     * Storage.copy() already builds and encodes the 'x-amz-copy-source' header internally\n     * from the key we give it. Pre-encoding it here caused a double-encoding bug (e.g. a\n     * space became \"%2520\" instead of \"%20\"), so Storage.copy() looked for a key that never\n     * existed on S3, resulting in a NoSuchKey error.\n     */\n    private extractS3KeyFromValue(value: string): string {\n        if (!value) {\n            return '';\n        }\n\n        let extracted = value;\n\n        // 1. Extract path from URL and drop query params\n        if (value.startsWith('http://') || value.startsWith('https://')) {\n            try {\n                const url = new URL(value);\n                extracted = decodeURIComponent(url.pathname);\n            } catch {\n                extracted = value.split('?')[0];\n            }\n        } else {\n            extracted = value.split('?')[0];\n        }\n\n        // 2. Remove leading slash\n        if (extracted.startsWith('/')) {\n            extracted = extracted.substring(1);\n        }\n\n        // 3. Remove 'public/' prefix\n        // Amplify prepends this automatically; we must strip it from the input\n        // to avoid the 'public/public/' double-prefix issue.\n        if (extracted.startsWith('public/')) {\n            extracted = extracted.substring('public/'.length);\n        }\n\n        // Return the raw key as-is — Storage.copy() takes care of properly encoding it\n        // for the CopySource header. Do NOT re-encode it here.\n        return extracted;\n    }\n}"]}
+        }], 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.HashtagService }, { type: i11.MissionService }, { type: i12.OperationService }, { type: i13.DomainService }, { type: i14.TranslateService }, { type: i15.ZoneService }] });
+//# 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 { HashtagService } from './models/hashtag.service';\r\nimport { MissionService } from './models/mission.service';\r\nimport { OperationService } from './models/operation.service';\r\nimport { DomainService } from './models/domain.service';\r\nimport { ZoneService } from './models/zone.service';\r\nimport { BaseUserService } from './user.service';\r\nimport { copyFileInS3, copyFileInS3ViaDownload, getSignedFile } from './s3.service'; // see s3.service.ts: neither must swallow errors (needed to detect NoSuchKey / signature mismatch below)\r\nimport { downloadBlob } from '../helpers.service';\r\nimport { API, graphqlOperation } from 'aws-amplify';\r\nimport {\r\n    computeRigidTransform, applyRigidTransformToPoint, applyRigidTransformToDirection, distance,\r\n    applyRigidTransformToYRotationDeg, RigidTransform, Vec3\r\n} from './utils/matterport-transform.util';\r\nimport { Object3D, Feature, Measurement, Comment, CommentType, PoiType, Equipment, SpModule, Ticket, Hashtag, Mission, Operation, Domain } 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' | 'recalibrating' | '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    /** Items that already existed in the target space and had missing identity fields\r\n     *  filled in, rather than being newly created — see healEquipmentIdentity() and its\r\n     *  ticket/feature equivalents. */\r\n    healedCount: number;\r\n}\r\n\r\n/** A single line in the copy log — a step status (updated in place), or an error / healed\r\n *  item notice (appended once, permanent). */\r\nexport interface CopyLogEntry {\r\n    id: string;       // stable id for step lines (so they update in place), unique for error/healed lines\r\n    type: 'step' | 'error' | 'healed';\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/** Kind of record a POI's elementID points at (a measurement POI points at a Comment). */\r\ntype TagElementType = 'ticket' | 'equipment' | 'object3D' | 'feature' | 'comment';\r\n\r\n/** What recalibration needs to know about a tag's element. */\r\ninterface TagElement {\r\n    name: string;\r\n    identity: Array<string | null | undefined>;\r\n    /** space (location) the element belongs to */\r\n    spaceId?: string | null;\r\n    /** free text shown in the tag preview (ticket description, ...) */\r\n    description?: string;\r\n    /** S3 value of the element's picture (a measurement's screenshot) */\r\n    imageKey?: string;\r\n}\r\n\r\n/** A tag listed for recalibration, with what the UI needs to identify it. */\r\nexport type RecalibrationTag = POI & {\r\n    elementName: string;\r\n    elementDescription?: string;\r\n    /** pass to getTagImageUrl() to get a displayable (signed) URL */\r\n    elementImageKey?: string;\r\n    /** floor zone (layer FLOOR) of the tag's sweep in the target space */\r\n    floorName?: string;\r\n    /** most specific other zone of the tag's sweep in the target space */\r\n    zoneName?: string;\r\n};\r\n\r\n/**\r\n * Which tags of a space (location) a recalibration lists. A tag belongs to a location (the\r\n * space of the element it points at; a standalone tag belongs to every location showing it)\r\n * and is displayed in one or several virtual visits of that location. Tags of another\r\n * location are never listed, even when both locations use the same visit.\r\n *  - SPACE: every tag of the location, whichever of its visits it sits in;\r\n *  - VISIT: the tags of the location placed on the sweeps of the selected visit.\r\n */\r\nexport type RecalibrationTagScope = 'SPACE' | 'VISIT';\r\n\r\n/** Both lists getRecalibrationTagSets() offers, see there. */\r\nexport interface RecalibrationTagSets {\r\n    space: RecalibrationTag[];\r\n    visit: RecalibrationTag[];\r\n}\r\n\r\nexport interface RecalibrationTagOptions {\r\n    /** Node of the selected target visit (visit.node.id): drives the VISIT list. */\r\n    targetNodeId?: string | null;\r\n    /** Only keep the tags that also exist in the source location (ignored when source = target). */\r\n    onlyTagsInSource?: boolean;\r\n}\r\n\r\n/** Outcome of recalibrateTagsFromVisit(): how many of the selected tags were moved. */\r\nexport interface RecalibrationResult {\r\n    updated: number;\r\n    /** selected tags not found anymore, or without a position to move */\r\n    skipped: number;\r\n    failed: number;\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    /** Unique-id sequence shared by every permanent (non-step) log line — errors and healed-item notices alike. */\r\n    private logSeq = 0;\r\n\r\n    // ---- Per-run remapping state (reset by resetRunState() at the start of every copy) ----\r\n\r\n    /** source element id -> id of its copy in the target space. */\r\n    private elementIds: Record<string, string> = {};\r\n\r\n    /** source Comment id -> id of its copy. Needed to remap POI.tagImageID, which is a\r\n     *  reference to a Comment record (see the schema: \"connection to comment.id\"). */\r\n    private commentIds: Map<string, string> = new Map();\r\n\r\n    // Hashtags are space-scoped records, so their ids can never be carried over as-is: they\r\n    // are matched by NAME against the target space, and the missing ones are created there.\r\n    // That creation is deliberately lazy — see resolveHashtagIds() — and audited, so an\r\n    // interrupted copy cannot leave keywords behind that no POI references.\r\n\r\n    /** source Hashtag id -> its name. */\r\n    private sourceHashtagNames: Map<string, string> = new Map();\r\n\r\n    /** normalised hashtag name -> its id in the TARGET space (pre-existing or just created). */\r\n    private targetHashtagIdsByName: Map<string, string> = new Map();\r\n\r\n    /** ids of the hashtags this run created in the target space. */\r\n    private createdHashtagIds: Set<string> = new Set();\r\n\r\n    /** ids of the hashtags actually persisted on a successfully created feature. Anything in\r\n     *  createdHashtagIds but absent here is an orphan and is deleted at the end of the run. */\r\n    private usedHashtagIds: Set<string> = new Set();\r\n\r\n    /** source ids of the elements whose POIs were already created by an element phase.\r\n     *  Guards the standalone POI phase against creating a second, impoverished copy. */\r\n    private handledElementIds: Set<string> = new Set();\r\n\r\n    // Comment authorship: `Comment.ownerID` is a foreign key to a Mission, and a Mission is\r\n    // scoped to ONE space (userID + spaceID). A source comment's ownerID therefore points at\r\n    // nobody in the target space, so it has to be translated to the Mission of the SAME user\r\n    // there — see resolveCommentOwnerID().\r\n\r\n    /** source Mission id -> its userID. */\r\n    private sourceMissionUserIds: Map<string, string> = new Map();\r\n\r\n    /** userID -> that user's Mission id in the TARGET space (only set when they have one). */\r\n    private targetMissionIdsByUserId: Map<string, string> = new Map();\r\n\r\n    // Domain (equipment/ticket/feature/POI category) resolution mirrors the exact rule the\r\n    // edit forms use to populate their own category dropdown —\r\n    // DomainService.getDomainsForOrgForType(type, mission.organisationID,\r\n    // mission.orderedOrganisationID) — keyed to the OPERATOR's own Mission on each space,\r\n    // NOT to the Space's own organisationID. Two spaces in different organisations can\r\n    // still share a domain through that Mission link (an operator whose mission on the\r\n    // target space carries an `orderedOrganisationID` matching the domain's own\r\n    // organisationID sees — and can reuse — it directly). See resolveDomainID().\r\n\r\n    /** id -> Domain, for every domain visible from EITHER space's operator mission (its\r\n     *  organisationID, its orderedOrganisationID, or generic/no-organisation domains) — a\r\n     *  superset covering whatever a source object's domainID could point at. */\r\n    private domainsById: Map<string, Domain> = new Map();\r\n\r\n    /** organisationIDs the TARGET operator's mission can see domains from. A domain whose\r\n     *  own organisationID is in this set (or has none at all) is already directly\r\n     *  selectable in the target space's own dropdown, so its id is reused unchanged. */\r\n    private targetVisibleDomainOrgIds: Set<string> = new Set();\r\n\r\n    /** `${type}::${normalised name}` -> that domain's id, among domains visible to the\r\n     *  TARGET operator — used to find an equivalent when the exact id isn't reusable. */\r\n    private targetDomainIdsByTypeAndName: Map<string, string> = new Map();\r\n\r\n    /** Target space id of the run in progress — used to re-home copied tag icons. */\r\n    private targetSpaceId: string | null = null;\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 hashtagService: HashtagService,\r\n        private missionService: MissionService,\r\n        private operationService: OperationService,\r\n        private domainService: DomainService,\r\n        private translate: TranslateService,\r\n        private zoneService: ZoneService\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        let healedCount = 0;\r\n        // items skipped because an equivalent already exists in the target (earlier run)\r\n        let alreadyPresentCount = 0;\r\n        this.resetLog();\r\n        this.resetRunState(targetSpaceId);\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, healedCount: 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 = this.elementIds;\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            // Paginated: a space routinely holds more than the 100 features a single AppSync\r\n            // page returns, and the tail was silently dropped.\r\n            //\r\n            // The source list keeps the historical \"skip what the operator archived\" rule, so\r\n            // the set of copied features does not change — but the check is now null-safe:\r\n            // FeatureService.isArchived() dereferences currentMission(spaceID).id and threw a\r\n            // TypeError when the operator had no mission on the source space (the common case\r\n            // for an archived v1 space), aborting the whole copy.\r\n            // The target list is NOT filtered: it only feeds duplicate detection, and an\r\n            // archived feature is still a feature that exists there.\r\n            const sourceFeatures = (await this.featureService.getAllFeaturesBySpaceRaw(sourceSpaceId))\r\n                .filter(feature => !this.isArchivedForOperator(feature, sourceSpaceId));\r\n            const targetFeatures = await this.featureService.getAllFeaturesBySpaceRaw(targetSpaceId);\r\n\r\n            this.setStepProgress('collecting', 'collecting', 75);\r\n\r\n            // Keywords: index both vocabularies now (read-only). The keywords the target space\r\n            // is missing are created later, POI by POI, only for those actually used.\r\n            await this.loadHashtagIndex(sourceSpaceId, targetSpaceId);\r\n\r\n            // Missions: index both spaces now (read-only), so copied comments can credit\r\n            // their real author instead of whoever is running the copy.\r\n            await this.loadMissionIndex(sourceSpaceId, targetSpaceId);\r\n\r\n            // Domains: index every domain either operator's mission can see (read-only), so\r\n            // a category survives a copy across two DIFFERENT organisations whenever it\r\n            // genuinely would be selectable in the target space's own dropdown — see\r\n            // loadDomainIndex() for why this is keyed to Mission, not to the Space itself.\r\n            await this.loadDomainIndex(sourceSpaceId, targetSpaceId);\r\n\r\n            if (this.spModule == SpModule.IMMO) {\r\n                sourceMeasurements = (await this.measurementService.getMeasurementsForSpaceForUser(sourceSpaceId))\r\n                    .filter(m => (m.numberPoints ?? 0) > 0)\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            // A POI is \"owned\" by an element (ticket, equipment, 3D object, feature, measurement)\r\n            // when its elementID points at one. Those POIs are created by their element's phase,\r\n            // which is the only place that knows the element's NEW id — so they must be excluded\r\n            // from the standalone phase, otherwise every feature ends up with two POIs: one\r\n            // correctly linked but stripped of its tag metadata, and one carrying the metadata\r\n            // but still pointing at the source space's element.\r\n            //\r\n            // Ownership is recognised by TWO independent criteria, and either one is enough to\r\n            // keep a POI out of the standalone phase:\r\n            //\r\n            //  - its type is one an element phase is responsible for. This is the historical\r\n            //    rule and it must be kept: a POI of that type whose element was NOT collected\r\n            //    (deleted ticket, equipment outside the current filter, ...) is an orphan, and\r\n            //    copying it standalone would recreate it with an elementID still pointing into\r\n            //    the source space — an orphan the previous version correctly refused to copy.\r\n            //  - its elementID belongs to an element we actually collected. This is the added\r\n            //    rule, needed because the type alone is not a reliable discriminator: historical\r\n            //    data also holds INFORMATION/ROOM POIs bound to a feature, which the type test\r\n            //    lets through and which would end up duplicated.\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\r\n            for (const owner of [...sourceTickets, ...sourceEquipments, ...sourceObjects3D, ...sourceFeatures]) {\r\n                if (owner?.id) {\r\n                    this.handledElementIds.add(owner.id);\r\n                }\r\n            }\r\n            for (const measurement of sourceMeasurements) {\r\n                // a measurement POI is bound to the measurement's Comment, not to the measurement\r\n                if (measurement?.comment?.id) {\r\n                    this.handledElementIds.add(measurement.comment.id);\r\n                }\r\n            }\r\n\r\n            const isOwnedByAnElement = (poi: POI) =>\r\n                handledPoiTypes.has(poi.type as string)\r\n                || (!!poi.elementID && this.handledElementIds.has(poi.elementID));\r\n\r\n            const sourcePois = sourcePoisAll.filter(p => !isOwnedByAnElement(p));\r\n            const targetPois = targetPoisAll.filter(p => !!p);\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, healedCount\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 existingMatch = this.findExisting(\r\n                            sourceObj as any, targetTickets as any,\r\n                            (t: any) => [t.title, t.description]\r\n                        );\r\n\r\n                        if (existingMatch) {\r\n                            alreadyPresentCount++;\r\n                        }\r\n                        if (!existingMatch) {\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                                // Missions are per-space: a source mission id designates nobody in\r\n                                // the target space. Carrying the list over would look like real data\r\n                                // while hiding the item from no one — reset it, as for features.\r\n                                archivedForMissionID: null,\r\n                                spaceID: targetSpaceId,\r\n                                // Remapped in the second pass below, once every ticket exists.\r\n                                parentID: null,\r\n                                // Reused unchanged in the same organisation, matched by name\r\n                                // across two — see resolveDomainID().\r\n                                domainID: this.resolveDomainID(rawSource.domainID),\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                            // Attachments of the ticket (photos of the incident, documents...).\r\n                            // They were never copied at all: a duplicated ticket arrived stripped\r\n                            // of every piece of evidence attached to it.\r\n                            if (createdObj) {\r\n                                let sourceComments: Comment[] = [];\r\n                                try {\r\n                                    sourceComments = await this.commentService.getAllCommentsForTicket(sourceObj.id);\r\n                                } catch (commentsFetchError) {\r\n                                    console.warn(`Falling back to the embedded comment list for ticket \"${rawSource.title}\":`, commentsFetchError);\r\n                                    sourceComments = (sourceObj.comments?.items || []).filter(c => !!c) as Comment[];\r\n                                }\r\n\r\n                                for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {\r\n                                    try {\r\n                                        const created = await this.copyCommentForTicket(\r\n                                            sourceComment, createdObj.id, targetSpaceId\r\n                                        );\r\n                                        if (created?.id && (sourceComment as any).id) {\r\n                                            this.commentIds.set((sourceComment as any).id, created.id);\r\n                                        }\r\n                                    } catch (attachmentError) {\r\n                                        console.error(`Error copying attachment \"${sourceComment?.title}\" for ticket \"${sourceObj?.title}\":`, attachmentError);\r\n                                        errorCount++;\r\n                                        this.logCopyItemError(attachmentError, 'errorFeatureAttachment', sourceComment?.title || (sourceComment as any)?.id, {\r\n                                            feature: rawSource.title || sourceObj.id\r\n                                        });\r\n                                    }\r\n                                }\r\n                            }\r\n\r\n                            for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {\r\n                                await this.createCopiedPoi(\r\n                                    sourcePoi, createdObj.id,\r\n                                    sourceNavPositions, targetNavPositions, transform\r\n                                );\r\n                            }\r\n                        } else {\r\n                            // Same reasoning as the EQUIPMENTS phase (see the comment there):\r\n                            // a ticket matching this one already exists in the target space,\r\n                            // most likely from an earlier, incomplete run. Fill in whatever\r\n                            // identity field it is missing rather than leaving it untouched.\r\n                            elementIds[sourceObj.id] = existingMatch.id;\r\n                            const healedFields = await this.healTicketIdentity(sourceObj as any, existingMatch as any);\r\n                            if (healedFields.length > 0) {\r\n                                healedCount++;\r\n                                this.logHealedItem('ticketHealed', (sourceObj as any)?.title || sourceObj?.id, healedFields);\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                // Second pass: restore the ticket hierarchy. `parentID` had to be nulled during\r\n                // creation (the parent may not have existed yet) and was then never restored, so\r\n                // every sub-ticket came out detached. Same rule as for sub-equipments: a parent\r\n                // with no copied counterpart is dropped rather than left pointing at the source\r\n                // space's ticket.\r\n                for (const sourceObj of sourceTickets) {\r\n                    const rawSource = sourceObj as any;\r\n                    const newId = elementIds[sourceObj.id];\r\n                    const newParentId = rawSource.parentID ? elementIds[rawSource.parentID] : null;\r\n\r\n                    if (newId && newParentId) {\r\n                        try {\r\n                            await this.ticketService.updateTicket({ id: newId, parentID: newParentId });\r\n                        } catch (parentError) {\r\n                            console.error(`Error remapping the parent ticket of \"${sourceObj?.title}\":`, parentError);\r\n                            errorCount++;\r\n                            this.logCopyItemError(parentError, 'errorTicket', sourceObj?.title || sourceObj?.id);\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // EQUIPMENTS (identity, POI, PHOTO and NOTES/documents all copied — files\r\n                // physically duplicated in S3 first, so the copy stays independent from the source)\r\n                //\r\n                // CAREFUL: the Equipment model has NO `title` and NO `description` column. It\r\n                // identifies itself with `name` (String! — required) and annotates itself with\r\n                // `annotation`. Reading `rawSource.title` therefore always yielded undefined and\r\n                // the required `name` was never sent, which AppSync rejected with\r\n                // \"Variable 'input' has coerced Null value for NonNull type 'String!'\".\r\n                for (let i = 0; i < sourceEquipments.length; i++) {\r\n                    const sourceObj = sourceEquipments[i];\r\n\r\n                    try {\r\n                        // Equipment has no `title`/`description`: it identifies itself by name, and by\r\n                        // serial number when one is recorded.\r\n                        const existingMatch = this.findExisting(\r\n                            sourceObj as any, targetEquipments as any,\r\n                            (e: any) => [e.name, e.serialNumber]\r\n                        );\r\n\r\n                        if (existingMatch) {\r\n                            alreadyPresentCount++;\r\n                        }\r\n                        if (!existingMatch) {\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.name}\"`);\r\n                            }\r\n\r\n                            const equipmentInput: any = {\r\n                                name: rawSource.name,\r\n                                // Unlike every other model this file copies, Equipment declares\r\n                                // `createdAt` as a plain client-settable field rather than an\r\n                                // AppSync-managed timestamp (see schema.graphql) — so, uniquely\r\n                                // here, the original commissioning date can actually be kept\r\n                                // instead of the copy silently getting today's date.\r\n                                createdAt: rawSource.createdAt ?? null,\r\n                                annotation: rawSource.annotation ?? null,\r\n                                status: rawSource.status,\r\n                                // Full identity of the equipment — all of these were dropped\r\n                                family: rawSource.family ?? null,\r\n                                sku: rawSource.sku ?? null,\r\n                                serialNumber: rawSource.serialNumber ?? null,\r\n                                manufacturer: rawSource.manufacturer ?? null,\r\n                                installDate: rawSource.installDate ?? null,\r\n                                warrantyEndDate: rawSource.warrantyEndDate ?? null,\r\n                                metadata: rawSource.metadata ?? null,\r\n                                isCreatedByAI: rawSource.isCreatedByAI ?? null,\r\n                                // Missions are per-space: a source mission id designates nobody in\r\n                                // the target space. Carrying the list over would look like real data\r\n                                // while hiding the item from no one — reset it, as for features.\r\n                                archivedForMissionID: null,\r\n                                spaceID: targetSpaceId,\r\n                                // Reused unchanged in the same organisation, matched by name\r\n                                // across two — see resolveDomainID().\r\n                                domainID: this.resolveDomainID(rawSource.domainID),\r\n                                photo: copiedPhotoKey,\r\n                                // `subequipmentsIDs` is deliberately absent: it is remapped to the\r\n                                // copied equipments in the second pass, once they all exist.\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                                        // A note without a file is still a note: it carries a type\r\n                                        // and its signature/expiry dates. Skipping it, as was done\r\n                                        // before, silently dropped those records entirely.\r\n                                        const copiedKey = sourceNote.attachment\r\n                                            ? await this.copyS3KeyIfPresent(sourceNote.attachment, `equipment note for \"${sourceObj?.name}\"`)\r\n                                            : null;\r\n                                        await this.equipmentService.createNoteWithExistingAttachment(\r\n                                            createdObj.id, copiedKey, sourceNote.type, targetMissionId,\r\n                                            {\r\n                                                signDate: sourceNote.signDate ?? null,\r\n                                                expirationDate: sourceNote.expirationDate ?? null\r\n                                            }\r\n                                        );\r\n                                    } catch (noteError) {\r\n                                        console.error(`Error copying note for equipment \"${sourceObj?.name}\":`, noteError);\r\n                                        errorCount++;\r\n                                        this.logCopyItemError(noteError, 'errorEquipmentNote', sourceObj?.name || sourceObj?.id, {\r\n                                            equipment: sourceObj?.name || sourceObj?.id\r\n                                        });\r\n                                    }\r\n                                }\r\n                            }\r\n\r\n                            for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {\r\n                                await this.createCopiedPoi(\r\n                                    sourcePoi, createdObj.id,\r\n                                    sourceNavPositions, targetNavPositions, transform\r\n                                );\r\n                            }\r\n                        } else {\r\n                            // An equipment matching this one already exists in the target space —\r\n                            // most often because a PREVIOUS run of this copy already created it.\r\n                            // That earlier run may have been interrupted, or hit a bug that has\r\n                            // since been fixed (missing family/manufacturer/domainID/... were once\r\n                            // dropped entirely — see the comment above), leaving an equipment with\r\n                            // its identity fields empty forever: re-running the copy used to skip\r\n                            // it outright, since it already \"exists\", so the gap could never heal.\r\n                            //\r\n                            // Re-running the tool must be able to repair that: any identity field\r\n                            // the existing target equipment is missing, and the source has, is\r\n                            // filled in. Fields the target already carries a value for are left\r\n                            // untouched, so a manual edit made in the target space is never\r\n                            // overwritten by an older or different source value. Notes and POIs are\r\n                            // NOT re-created here: unlike scalar fields they cannot be \"missing vs.\r\n                            // present\" checked the same way, and re-adding them on every re-run of\r\n                            // an already-healthy copy would duplicate them.\r\n                            elementIds[sourceObj.id] = existingMatch.id;\r\n                            const healedFields = await this.healEquipmentIdentity(sourceObj as any, existingMatch as any);\r\n                            if (healedFields.length > 0) {\r\n                                healedCount++;\r\n                                this.logHealedItem('equipmentHealed', (sourceObj as any)?.name || sourceObj?.id, healedFields);\r\n                            }\r\n                        }\r\n                    } catch (itemError) {\r\n                        console.error(`Error copying equipment \"${sourceObj?.name}\" (id: ${sourceObj?.id}):`, itemError);\r\n                        errorCount++;\r\n                        this.logCopyItemError(itemError, 'errorEquipment', sourceObj?.name || 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?.name}\":`, subEquipError);\r\n                                errorCount++;\r\n                                this.logCopyItemError(subEquipError, 'errorEquipmentSubEquip', sourceObj?.name || sourceObj?.id, {\r\n                                    equipment: sourceObj?.name || sourceObj?.id\r\n                                });\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // OPERATIONS — the Ticket<->Equipment join (drives \"Tickets actuels\" on the\r\n                // equipment page and the linked-equipment list on the ticket page). Both the\r\n                // TICKETS and EQUIPMENTS phases above copy the record itself, but neither one\r\n                // touches this join table, so every link between a copied ticket and a copied\r\n                // equipment was silently dropped: both sides existed in the target space, but\r\n                // pointing at nobody.\r\n                //\r\n                // Runs after both phases, over every SOURCE ticket that ended up mapped in\r\n                // the target space (freshly created OR healed — elementIds covers both), so a\r\n                // re-run over an already-copied pair of spaces can still pick up links that\r\n                // an earlier, incomplete run never created.\r\n                for (const sourceTicket of sourceTickets) {\r\n                    const newTicketId = elementIds[sourceTicket.id];\r\n                    if (!newTicketId) {\r\n                        continue;\r\n                    }\r\n\r\n                    try {\r\n                        const sourceOps = await this.operationService.getOperationsByTicketID(sourceTicket.id);\r\n                        if (sourceOps.length === 0) {\r\n                            continue;\r\n                        }\r\n\r\n                        // Read what the target ticket is already linked to, so a re-run never\r\n                        // creates a duplicate Operation for a link that already exists.\r\n                        const targetOps = await this.operationService.getOperationsByTicketID(newTicketId);\r\n                        const linkedEquipmentIds = new Set(targetOps.map(op => op.equipmentID));\r\n\r\n                        for (const sourceOp of sourceOps) {\r\n                            const newEquipmentId = sourceOp.equipmentID ? elementIds[sourceOp.equipmentID] : null;\r\n                            // No copied counterpart for the source equipment (not collected,\r\n                            // outside the current filter, ...) — same rule as everywhere else\r\n                            // in this file: drop the link rather than point it at nothing or\r\n                            // at the source space's equipment.\r\n                            if (!newEquipmentId || linkedEquipmentIds.has(newEquipmentId)) {\r\n                                continue;\r\n                            }\r\n                            await this.operationService.createOperation({ ticketID: newTicketId, equipmentID: newEquipmentId } as Operation);\r\n                            linkedEquipmentIds.add(newEquipmentId);\r\n                        }\r\n                    } catch (opError) {\r\n                        console.error(`Error copying ticket-equipment links for \"${sourceTicket?.title}\":`, opError);\r\n                        errorCount++;\r\n                        this.logCopyItemError(opError, 'errorOperation', sourceTicket?.title || sourceTicket?.id);\r\n                    }\r\n                }\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                        alreadyPresentCount++;\r\n                    }\r\n                    if (!existsInTarget) {\r\n                        const rawSource = sourceObj as any;\r\n\r\n                        // `path` means two different things depending on `s3Bucket`, exactly as the\r\n                        // viewer reads it (see viewer.component.ts and matterport-object3d.service.ts):\r\n                        //  - s3Bucket === true  -> a key of a model file uploaded to S3, ours to duplicate;\r\n                        //  - otherwise          -> a reference into the 3D object library shipped with\r\n                        //    the application (\"3DObjects/objects/cube.dae\" -> assets/3Dobjects/...),\r\n                        //    which exists in every space and must be reused verbatim.\r\n                        // Copying unconditionally meant every library object failed with NoSuchKey and\r\n                        // the whole 3D object was skipped, model AND POI.\r\n                        let copiedPath = rawSource.path;\r\n                        if (rawSource.path && rawSource.s3Bucket) {\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                        // This service is shared, but the two applications do NOT deploy the same\r\n                        // Object3D schema: `viewFrustum` exists only in smarterplan, and `scale`\r\n                        // is [Float] there but a plain Float in museum. Sending the smarterplan\r\n                        // shape to museum was rejected with \"The variables input contains a field\r\n                        // that is not defined for input object type 'CreateObject3DInput'\".\r\n                        //\r\n                        // The input therefore MIRRORS the source record instead of imposing a\r\n                        // shape: source and target live in the same deployment, so whatever the\r\n                        // source carries is exactly what the target accepts.\r\n                        const object3DInput: any = {\r\n                            path: copiedPath,\r\n                            // Tells the viewer how to interpret `path`. Dropping it turned an\r\n                            // S3-hosted model into a library reference on the copy, which the\r\n                            // viewer then tried to resolve against assets/ and failed to load.\r\n                            s3Bucket: !!rawSource.s3Bucket,\r\n                            name: rawSource.name,\r\n                            description: rawSource.description || \"\",\r\n                            spaceID: targetSpaceId,\r\n                            position: toFloatArray(rawSource.position, [0, 0, 0]),\r\n                            rotation: toFloatArray(rawSource.rotation, [0, 0, 0])\r\n                        };\r\n\r\n                        if ('viewFrustum' in rawSource) {\r\n                            object3DInput.viewFrustum = !!rawSource.viewFrustum;\r\n                        }\r\n\r\n                        // Scale keeps the source's own shape: a list stays a list, a scalar stays\r\n                        // a scalar. An absent scale is left unset rather than invented, so the copy\r\n                        // renders exactly like the original.\r\n                        if (Array.isArray(rawSource.scale)) {\r\n                            object3DInput.scale = toFloatArray(rawSource.scale, [1, 1, 1]);\r\n                        } else if (rawSource.scale !== null && rawSource.scale !== undefined) {\r\n                            const scalarScale = parseFloat(rawSource.scale);\r\n                            object3DInput.scale = Number.isNaN(scalarScale) ? 1 : scalarScale;\r\n                        }\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                        for (const sourcePoi of (sourceObj.pois?.items || []).filter(p => !!p)) {\r\n                            await this.createCopiedPoi(\r\n                                sourcePoi, createdObj.id,\r\n                                sourceNavPositions, targetNavPositions, transform\r\n                            );\r\n                        }\r\n                    }\r\n                } catch (itemError) {\r\n                    // The backend can deny creation of this whole model to the signed-in account\r\n                    // (in MUSEUM, Object3D only grants get/list to userPools). The denial is not\r\n                    // per-item, so every remaining object would fail identically: report it once,\r\n                    // as a permission problem rather than a copy error, and stop the phase instead\r\n                    // of firing one doomed mutation per object.\r\n                    if (this.isUnauthorized(itemError)) {\r\n                        const remaining = sourceObjects3D.length - i;\r\n                        console.warn(`[MatterportTagCopyService] Not allowed to create 3D objects in the target space, skipping ${remaining} of them.`, itemError);\r\n                        errorCount++;\r\n                        this.logItemError('errorObjects3dNotAllowed', { count: remaining });\r\n\r\n                        processedOverall += remaining;\r\n                        emitProgress('objects3d', sourceObjects3D.length, sourceObjects3D.length);\r\n                        this.setStepProgress('objects3d', 'objects3d', 100);\r\n                        break;\r\n                    }\r\n\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 — the \"POI\" of the MUSEUM module: its own record (title, index, locale,\r\n            // keywords), its media set (one Comment per image/video/audio/document/link/text)\r\n            // and its POI record (the pastille: icon, tag description, cover image).\r\n            // Everything is copied here, files 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 existingMatch = this.findExisting(\r\n                        sourceObj as any, targetFeatures as any,\r\n                        (f: any) => [f.title, f.description]\r\n                    );\r\n\r\n                    if (existingMatch) {\r\n                        alreadyPresentCount++;\r\n                    }\r\n                    if (!existingMatch) {\r\n                        const rawSource = sourceObj as any;\r\n\r\n                        // Resolved just before the write: a keyword is only created in the target\r\n                        // space when the POI carrying it is about to be created.\r\n                        const resolvedHashtags = await this.resolveHashtagIds(rawSource.hashtags, targetSpaceId);\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                            // `index` drives the ordering of the POI in the space's list, in the\r\n                            // lateral menu and in the guided tour. Dropping it forced a full manual\r\n                            // renumbering of every copied POI.\r\n                            index: rawSource.index ?? null,\r\n                            // Missions are per-space: source mission ids mean nothing in the target\r\n                            // space, so an archive list carried over would hide POIs from nobody\r\n                            // while looking like real data. Reset instead.\r\n                            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 are space-scoped records: the ids must be translated to the\r\n                            // equivalent hashtags of the target space (created on demand).\r\n                            hashtags: resolvedHashtags,\r\n                            description: rawSource.description || null,\r\n                            // Reused unchanged in the same organisation, matched by name\r\n                            // across two — see resolveDomainID().\r\n                            domainID: this.resolveDomainID(rawSource.domainID),\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                            // The feature exists: its keywords are now genuinely referenced and\r\n                            // must survive the end-of-run cleanup.\r\n                            this.markHashtagsUsed(resolvedHashtags);\r\n                        }\r\n\r\n                        if (createdObj) {\r\n                            // Read the media set through its own paginated query: the `comments`\r\n                            // connection embedded in FeaturesBySpace is capped at 100 items and its\r\n                            // nextToken was never followed, so rich POIs lost attachments silently.\r\n                            let sourceComments: Comment[] = [];\r\n                            try {\r\n                                sourceComments = await this.commentService.getAllCommentsForFeature(sourceObj.id);\r\n                            } catch (commentsFetchError) {\r\n                                console.warn(`Falling back to the embedded comment list for feature \"${rawSource.title}\":`, commentsFetchError);\r\n                                sourceComments = (sourceObj.comments?.items || []).filter(c => !!c) as Comment[];\r\n                            }\r\n\r\n                            for (const sourceComment of this.orderCommentsForCopy(sourceComments)) {\r\n                                try {\r\n                                    const created = await this.copyCommentForFeature(\r\n                                        sourceComment, createdObj.id, targetSpaceId\r\n                                    );\r\n                                    if (created?.id && (sourceComment as any).id) {\r\n                                        this.commentIds.set((sourceComment as any).id, created.id);\r\n                                    }\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 as any)?.id, {\r\n                                        feature: rawSource.title || sourceObj.id\r\n                                    });\r\n                                }\r\n                            }\r\n\r\n                            // Every POI of the feature, not only the first one: a feature may be\r\n                            // pinned at several places, and only this phase knows the new element id.\r\n                            const sourceFeaturePois = (sourceObj.pois?.items || []).filter(p => !!p);\r\n                            for (const sourcePoi of sourceFeaturePois) {\r\n                                await this.createCopiedPoi(\r\n                                    sourcePoi, createdObj.id,\r\n                                    sourceNavPositions, targetNavPositions, transform\r\n                                );\r\n                            }\r\n                        }\r\n                    } else {\r\n                        // Same reasoning as the EQUIPMENTS phase (see the comment there): a\r\n                        // feature matching this one already exists in the target space, most\r\n                        // likely from an earlier, incomplete run. Fill in whatever identity\r\n                        // field it is missing rather than leaving it untouched.\r\n                        elementIds[sourceObj.id] = existingMatch.id;\r\n                        const healedFields = await this.healFeatureIdentity(sourceObj as any, existingMatch as any);\r\n                        if (healedFields.length > 0) {\r\n                            healedCount++;\r\n                            this.logHealedItem('featureHealed', (sourceObj as any)?.title || sourceObj?.id, healedFields);\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                    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                            alreadyPresentCount++;\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                                description: rawComment.description ?? null,\r\n                                metadata: rawComment.metadata ?? null,\r\n                                type: CommentType.MEASURE,\r\n                                dimensions: rawComment.dimensions || null,\r\n                                annexe: copiedAnnexe,\r\n                                spaceID: targetSpaceId,\r\n                                // Same authorship rule as every other copied comment — see\r\n                                // resolveCommentOwnerID().\r\n                                ownerID: this.resolveCommentOwnerID(rawComment.ownerID),\r\n                            };\r\n\r\n                            const createdComment: Comment = await this.commentService.createComment(commentInput);\r\n\r\n                            if (createdComment && (createdComment as any).id && rawComment.id) {\r\n                                this.commentIds.set(rawComment.id, (createdComment as any).id);\r\n                            }\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                                    // Same treatment as any other POI: the source's Matterport tag\r\n                                    // SID must not travel, and the stem normal has to be rotated.\r\n                                    metadata: this.getAdjustedPoiMetadata(sourceMeasurement.poi.metadata, transform),\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            // POIS — standalone ones only: every POI owned by an element was already created by\r\n            // that element's phase, with the element's NEW id.\r\n            //\r\n            // This phase runs LAST on purpose. It used to run third, before 3D objects, features\r\n            // and measurements existed in the target space, so `elementIds` and `commentIds` were\r\n            // still empty when it needed them: elementID stayed pointing at the source space and\r\n            // tagImageID (a reference to a Comment record) could never be resolved.\r\n            for (let i = 0; i < sourcePois.length; i++) {\r\n                const sourcePoi = sourcePois[i];\r\n\r\n                try {\r\n                    // Compared on the parsed position, where the copy WOULD land: the stored strings\r\n                    // differ in format ('{ \"x\":' vs '{\"x\":') and, once landmarks move the tags, the\r\n                    // source string never equals its copy's, so every re-run duplicated these POIs.\r\n                    const expectedPosition = this.parseCoordinate(this.getAdjustedPositionOnly(\r\n                        sourcePoi.coordinate, transform));\r\n                    const existsInTarget = targetPois.some(\r\n                        tp => tp.tagDescription === sourcePoi.tagDescription\r\n                            && this.isSamePosition(this.parseCoordinate(tp.coordinate), expectedPosition)\r\n                    );\r\n\r\n                    if (existsInTarget) {\r\n                        alreadyPresentCount++;\r\n                    }\r\n                    if (!existsInTarget) {\r\n                        const elementID = sourcePoi.elementID\r\n                            ? (elementIds[sourcePoi.elementID] || sourcePoi.elementID)\r\n                            : sourcePoi.elementID;\r\n\r\n                        await this.createCopiedPoi(\r\n                            sourcePoi, elementID,\r\n                            sourceNavPositions, targetNavPositions, transform\r\n                        );\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                        sweep: sourcePoi?.matterportSweepID\r\n                    });\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            this.copyProgress$.next({\r\n                phase: 'done',\r\n                processedInPhase: 0, totalInPhase: 0,\r\n                processedOverall, totalOverall,\r\n                percent: 100, errorCount, healedCount\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            // Separate summary line, on top of (not instead of) the done/doneWithErrors one\r\n            // above: healing is orthogonal to success/failure, an already-complete run can\r\n            // still have repaired items left over from an earlier, incomplete attempt.\r\n            if (healedCount > 0) {\r\n                this.setStepLog('healedSummary', this.translate.instant('matterportCopy.healedSummary', { count: healedCount }));\r\n            }\r\n            // Says plainly that a re-run created nothing new, instead of a bare \"success\".\r\n            if (alreadyPresentCount > 0) {\r\n                this.setStepLog('alreadyPresentSummary',\r\n                    this.translate.instant('matterportCopy.alreadyPresentSummary', { count: alreadyPresentCount }));\r\n            }\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        } finally {\r\n            // Every exit path — success, partial success, or general failure — gives back the\r\n            // keywords this run created but no copied POI ended up using. Placed in `finally`\r\n            // so an exception thrown mid-copy cannot leave them behind either.\r\n            await this.cleanupUnusedCreatedHashtags();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Serialises the current copy log (step lines as last emitted, plus every error and\r\n     * healed-item notice) to a plain-text file and triggers a browser download — wired to a\r\n     * \"download log\" button in the copy UI, so an operator can keep or share the full report\r\n     * of a run rather than only the ~200px scrollable panel showing it.\r\n     */\r\n    downloadLog(filename?: string): void {\r\n        const text = this.log.map(entry => entry.text).join('\\n');\r\n        const defaultName = `matterport-copy-log-${new Date().toISOString().replace(/[:.]/g, '-')}.txt`;\r\n        downloadBlob(new Blob([text], { type: 'text/plain;charset=utf-8' }), filename || defaultName);\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.logSeq++;\r\n        this.log.push({ id: `error-${this.logSeq}`, type: 'error', text });\r\n        this.copyLog$.next([...this.log]);\r\n    }\r\n\r\n    /** Appends a permanent log line for an item that was repaired rather than newly\r\n     *  created — see healEquipmentIdentity() and its ticket/feature equivalents. */\r\n    private appendHealedLog(text: string) {\r\n        this.logSeq++;\r\n        this.log.push({ id: `healed-${this.logSeq}`, type: 'healed', 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.logSeq = 0;\r\n        this.copyLog$.next([]);\r\n    }\r\n\r\n    /** Clears every id map carried over from a previous run. The service is a root-level\r\n     *  singleton, so leftover mappings would silently link a new copy to records created\r\n     *  during the previous one. */\r\n    private resetRunState(targetSpaceId: string) {\r\n        this.elementIds = {};\r\n        this.commentIds = new Map();\r\n        this.sourceHashtagNames = new Map();\r\n        this.targetHashtagIdsByName = new Map();\r\n        this.createdHashtagIds = new Set();\r\n        this.usedHashtagIds = new Set();\r\n        this.handledElementIds = new Set();\r\n        this.sourceMissionUserIds = new Map();\r\n        this.targetMissionIdsByUserId = new Map();\r\n        this.domainsById = new Map();\r\n        this.targetVisibleDomainOrgIds = new Set();\r\n        this.targetDomainIdsByTypeAndName = new Map();\r\n        this.targetSpaceId = targetSpaceId;\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 a translated line for an item that already existed in the target space and had\r\n     *  its missing identity fields filled in, so the operator can tell it apart from a\r\n     *  freshly created item in the copy report. */\r\n    private logHealedItem(translationKey: string, itemLabel: string, healedFields: string[]): void {\r\n        const text = this.translate.instant(`matterportCopy.${translationKey}`, {\r\n            name: itemLabel,\r\n            fields: healedFields.join(', ')\r\n        });\r\n        this.appendHealedLog(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     *  `extraParams` carries the placeholders a few keys need on top of {{name}}/{{error}}\r\n     *  (e.g. errorFeatureAttachment's {{feature}}, errorPoi's {{sweep}}), which used to be\r\n     *  rendered as raw \"{{feature}}\" text in the log. */\r\n    private logCopyItemError(\r\n        error: unknown,\r\n        genericKey: string,\r\n        itemLabel: string,\r\n        extraParams: Record<string, any> = {}\r\n    ) {\r\n        if (error instanceof MissingS3FileError) {\r\n            this.logItemError('errorMissingS3FileSkipped', {\r\n                ...extraParams,\r\n                name: itemLabel,\r\n                file: error.sourceKey\r\n            });\r\n        } else {\r\n            this.logItemError(genericKey, { ...extraParams, name: itemLabel, error: toErrorMessage(error) });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Null-safe equivalent of FeatureService.isArchived(): true when the operator has archived\r\n     * this feature on that space. \"No mission on the space\" answers false (nothing archived)\r\n     * instead of throwing, which is what made a copy from a space the operator is not a member\r\n     * of fail outright.\r\n     */\r\n    private isArchivedForOperator(feature: Feature, spaceId: string): boolean {\r\n        const archivedFor = feature?.archivedForMissionID;\r\n        if (!archivedFor || archivedFor.length === 0) {\r\n            return false;\r\n        }\r\n        const mission = this.userService.currentMission(spaceId);\r\n        return mission?.id ? archivedFor.includes(mission.id) : false;\r\n    }\r\n\r\n    //\r\n    // ---------- Cross-space reference remapping ----------\r\n    //\r\n\r\n    /** Normalised lookup key for a domain: type disambiguates same-named domains used for\r\n     *  different purposes (equipment vs. ticket vs. feature categories, ...). */\r\n    private domainKey(type: any, name: string): string {\r\n        return `${type || ''}::${(name || '').trim().toLowerCase()}`;\r\n    }\r\n\r\n    /**\r\n     * READ-ONLY indexing of every domain either operator's Mission can see. Creates\r\n     * nothing — unlike hashtags, a domain is a business taxonomy entry an operator manages\r\n     * deliberately; this tool only ever reuses an EXISTING equivalent, it never invents one.\r\n     *\r\n     * Visibility is keyed to `currentMission(spaceId).organisationID` /\r\n     * `.orderedOrganisationID` for EACH space — exactly what\r\n     * `DomainService.getDomainsForOrgForType()` uses to populate the category dropdown on\r\n     * the equipment/ticket/feature edit forms (see form-equipment.component.ts,\r\n     * batch-edit-equipment.component.ts, form-feature.component.ts). Comparing the spaces'\r\n     * OWN `organisationID` instead — the previous approach — missed every domain reachable\r\n     * only through the operator's `orderedOrganisationID` (set when a mission is created \"on\r\n     * behalf of\" another organisation — see form-mission.component.ts), which is exactly how\r\n     * a domain ends up visible on two spaces that belong to different organisations.\r\n     */\r\n    private async loadDomainIndex(sourceSpaceId: string, targetSpaceId: string): Promise<void> {\r\n        const sourceMission = this.userService.currentMission(sourceSpaceId);\r\n        const targetMission = this.userService.currentMission(targetSpaceId);\r\n\r\n        const sourceOrgIds = [sourceMission?.organisationID, sourceMission?.orderedOrganisationID]\r\n            .filter((id): id is string => !!id);\r\n        const targetOrgIds = [targetMission?.organisationID, targetMission?.orderedOrganisationID]\r\n            .filter((id): id is string => !!id);\r\n        this.targetVisibleDomainOrgIds = new Set(targetOrgIds);\r\n\r\n        const allOrgIds = Array.from(new Set([...sourceOrgIds, ...targetOrgIds]));\r\n        if (allOrgIds.length === 0) {\r\n            // The operator has no mission on either space — nothing to resolve against;\r\n            // every domainID will be dropped, same as an unresolvable lookup elsewhere.\r\n            return;\r\n        }\r\n\r\n        try {\r\n            const domainLists = await Promise.all(\r\n                allOrgIds.map(orgId => this.domainService.getAllGenericDomainsAndForOrganisation(orgId))\r\n            );\r\n            for (const list of domainLists) {\r\n                for (const domain of list || []) {\r\n                    if (domain?.id) {\r\n                        this.domainsById.set(domain.id, domain);\r\n                    }\r\n                }\r\n            }\r\n        } catch (error) {\r\n            console.warn('[MatterportTagCopyService] Could not read the domains, cross-organisation categories will be dropped:', error);\r\n            return;\r\n        }\r\n\r\n        for (const domain of this.domainsById.values()) {\r\n            const visibleToTarget = !domain.organisationID || this.targetVisibleDomainOrgIds.has(domain.organisationID);\r\n            if (visibleToTarget && domain.name) {\r\n                this.targetDomainIdsByTypeAndName.set(this.domainKey(domain.type, domain.name), domain.id);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Resolves a source domainID (equipment/ticket/feature/POI category) for use in the\r\n     * target space.\r\n     *\r\n     *  - generic domain (no organisationID of its own — a shared taxonomy entry, e.g. a\r\n     *    standard category created by the platform): reused unchanged, valid everywhere.\r\n     *  - the domain's own organisationID is already one the TARGET operator's mission can\r\n     *    see (its organisationID, or its orderedOrganisationID): reused unchanged too — the\r\n     *    id is directly selectable in the target space's own dropdown as-is.\r\n     *  - otherwise: matched by (type, name) against the domains visible to the TARGET\r\n     *    operator (loadDomainIndex()); dropped when no equivalent exists there.\r\n     */\r\n    private resolveDomainID(sourceDomainId: string | null | undefined): string | null {\r\n        if (!sourceDomainId) {\r\n            return null;\r\n        }\r\n\r\n        const domain = this.domainsById.get(sourceDomainId);\r\n        if (!domain) {\r\n            // Not visible to either operator's mission (lookup failed, or it belongs to\r\n            // neither) — unchanged, safest to drop.\r\n            return null;\r\n        }\r\n        if (!domain.organisationID || this.targetVisibleDomainOrgIds.has(domain.organisationID)) {\r\n            return sourceDomainId;\r\n        }\r\n        return this.targetDomainIdsByTypeAndName.get(this.domainKey(domain.type, domain.name)) ?? null;\r\n    }\r\n\r\n    /** Normalised lookup key for a hashtag name, so \"Moyen Âge\" and \"moyen âge \" match. */\r\n    private hashtagKey(name: string): string {\r\n        return name.trim().toLowerCase();\r\n    }\r\n\r\n    /**\r\n     * READ-ONLY indexing of both spaces' hashtags. Creates nothing.\r\n     *\r\n     * `Feature.hashtags` stores Hashtag *ids*, and a Hashtag is a per-space record, so the\r\n     * ids have to be translated by name. The translation table is built here; the missing\r\n     * keywords are created later, one at a time, only when a POI that actually uses them is\r\n     * about to be written (see resolveHashtagIds()).\r\n     */\r\n    private async loadHashtagIndex(sourceSpaceId: string, targetSpaceId: string): Promise<void> {\r\n        let sourceHashtags: Hashtag[] = [];\r\n        let targetHashtags: Hashtag[] = [];\r\n\r\n        try {\r\n            [sourceHashtags, targetHashtags] = await Promise.all([\r\n                this.hashtagService.listHashtagsForSpace(sourceSpaceId),\r\n                this.hashtagService.listHashtagsForSpace(targetSpaceId)\r\n            ]);\r\n        } catch (error) {\r\n            console.warn('[MatterportTagCopyService] Could not read the hashtags, keywords will be dropped:', error);\r\n            return;\r\n        }\r\n\r\n        for (const hashtag of sourceHashtags || []) {\r\n            if (hashtag?.id && hashtag.name) {\r\n                this.sourceHashtagNames.set(hashtag.id, hashtag.name);\r\n            }\r\n        }\r\n        for (const hashtag of targetHashtags || []) {\r\n            if (hashtag?.id && hashtag.name) {\r\n                this.targetHashtagIdsByName.set(this.hashtagKey(hashtag.name), hashtag.id);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Translates one feature's hashtag ids into target-space ids, creating on the fly the\r\n     * keywords the target space does not have yet.\r\n     *\r\n     * Creation is LAZY on purpose. Doing it up front, for the whole source vocabulary, meant\r\n     * that a copy which failed or was closed halfway left behind keywords no POI referenced —\r\n     * pollution the operator had to clean up by hand. Here a keyword is only ever written\r\n     * when a POI that carries it is about to be created, so an interrupted copy stops\r\n     * creating keywords at the same POI it stops creating content.\r\n     *\r\n     * The residual window (keyword created, then createFeature fails) is closed by\r\n     * markHashtagsUsed() + cleanupUnusedCreatedHashtags().\r\n     *\r\n     * A keyword that can neither be found nor created is dropped rather than left as a\r\n     * dangling id.\r\n     */\r\n    private async resolveHashtagIds(\r\n        sourceHashtagIds: Array<string | null> | null | undefined,\r\n        targetSpaceId: string\r\n    ): Promise<string[] | null> {\r\n        if (!sourceHashtagIds || sourceHashtagIds.length === 0) {\r\n            return null;\r\n        }\r\n\r\n        const resolved: string[] = [];\r\n\r\n        for (const sourceId of sourceHashtagIds) {\r\n            if (!sourceId) {\r\n                continue;\r\n            }\r\n            const name = this.sourceHashtagNames.get(sourceId);\r\n            if (!name) {\r\n                // the source id points at a hashtag that no longer exists — nothing to carry over\r\n                continue;\r\n            }\r\n\r\n            const key = this.hashtagKey(name);\r\n            let targetId = this.targetHashtagIdsByName.get(key);\r\n\r\n            if (!targetId) {\r\n                try {\r\n                    const created = await this.hashtagService.createHashtagForSpace(name, targetSpaceId);\r\n                    targetId = created?.id;\r\n                    if (targetId) {\r\n                        this.targetHashtagIdsByName.set(key, targetId);\r\n                        this.createdHashtagIds.add(targetId);\r\n                    }\r\n                } catch (error) {\r\n                    console.warn(`[MatterportTagCopyService] Could not create the hashtag \"${name}\" in the target space:`, error);\r\n                    continue;\r\n                }\r\n            }\r\n\r\n            if (targetId && !resolved.includes(targetId)) {\r\n                resolved.push(targetId);\r\n            }\r\n        }\r\n\r\n        return resolved.length > 0 ? resolved : null;\r\n    }\r\n\r\n    /**\r\n     * READ-ONLY indexing of both spaces' missions.\r\n     *\r\n     * A Mission is scoped to one space (it pairs a userID with a spaceID), so the id a\r\n     * source comment's `ownerID` points at never designates anyone in the target space.\r\n     * This builds the two lookup tables resolveCommentOwnerID() needs to translate it:\r\n     * which user a source Mission id belongs to, and which Mission (if any) that same\r\n     * user already holds in the target space.\r\n     */\r\n    private async loadMissionIndex(sourceSpaceId: string, targetSpaceId: string): Promise<void> {\r\n        let sourceMissions: Mission[] = [];\r\n        let targetMissions: Mission[] = [];\r\n\r\n        try {\r\n            [sourceMissions, targetMissions] = await Promise.all([\r\n                this.missionService.getAllMissionsForSpace(sourceSpaceId),\r\n                this.missionService.getAllMissionsForSpace(targetSpaceId)\r\n            ]);\r\n        } catch (error) {\r\n            console.warn('[MatterportTagCopyService] Could not read the missions, comment authorship will be dropped:', error);\r\n            return;\r\n        }\r\n\r\n        for (const mission of sourceMissions || []) {\r\n            if (mission?.id && mission.userID) {\r\n                this.sourceMissionUserIds.set(mission.id, mission.userID);\r\n            }\r\n        }\r\n        for (const mission of targetMissions || []) {\r\n            if (mission?.id && mission.userID && !this.targetMissionIdsByUserId.has(mission.userID)) {\r\n                this.targetMissionIdsByUserId.set(mission.userID, mission.id);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Translates a source comment's `ownerID` (a per-space Mission id) into the Mission of\r\n     * the SAME user in the target space, so the copy keeps crediting its real author.\r\n     *\r\n     * Substituting the current operator's mission — the way `ownerMissionID` legitimately\r\n     * does for tickets/equipment/features, which really do change owner on a copy — would\r\n     * misattribute every comment to whoever ran the copy instead of who actually wrote it.\r\n     *\r\n     * When the original author has no mission in the target space (never granted access\r\n     * there), the comment is left with no owner rather than a wrong one: an absent author\r\n     * is honest, a misattributed one is not.\r\n     */\r\n    private resolveCommentOwnerID(sourceOwnerID: string | null | undefined): string | null {\r\n        if (!sourceOwnerID) {\r\n            return null;\r\n        }\r\n        const userID = this.sourceMissionUserIds.get(sourceOwnerID);\r\n        if (!userID) {\r\n            return null;\r\n        }\r\n        return this.targetMissionIdsByUserId.get(userID) ?? null;\r\n    }\r\n\r\n    /** Records that these hashtags are now referenced by a feature that really exists, so\r\n     *  the end-of-run cleanup leaves them alone. */\r\n    private markHashtagsUsed(hashtagIds: string[] | null): void {\r\n        for (const id of hashtagIds || []) {\r\n            this.usedHashtagIds.add(id);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Deletes the hashtags this run created that no copied POI ended up referencing.\r\n     *\r\n     * Runs on every exit path — success, general failure, or exception — so the target space\r\n     * never keeps keywords that came from an aborted copy. Only ids created by THIS run are\r\n     * ever considered: a pre-existing keyword of the target space is never touched, even if\r\n     * no copied POI uses it.\r\n     */\r\n    private async cleanupUnusedCreatedHashtags(): Promise<void> {\r\n        const orphans = [...this.createdHashtagIds].filter(id => !this.usedHashtagIds.has(id));\r\n        if (orphans.length === 0) {\r\n            return;\r\n        }\r\n\r\n        console.log(`[MatterportTagCopyService] Removing ${orphans.length} keyword(s) created but left unused by this copy.`);\r\n\r\n        for (const hashtagId of orphans) {\r\n            try {\r\n                await this.hashtagService.deleteHashtagById(hashtagId);\r\n                this.createdHashtagIds.delete(hashtagId);\r\n            } catch (error) {\r\n                // Cleanup is best-effort: a leftover keyword is harmless next to a failed copy,\r\n                // and must never be the reason the whole operation reports a failure.\r\n                console.warn(`[MatterportTagCopyService] Could not remove the unused keyword \"${hashtagId}\":`, error);\r\n            }\r\n        }\r\n    }\r\n\r\n    //\r\n    // ---------- Media content (Comments) ----------\r\n    //\r\n\r\n    /**\r\n     * Orders a feature's media set exactly the way the UI will read it back, and repairs\r\n     * the ordering key when the source data cannot express the user's intended order.\r\n     *\r\n     * The viewer sorts each media family on its own (`setImages`, `setVideos`, `setAudio`,\r\n     * `setDocuments`, ... all do `.sort((a, b) => a.index - b.index)`), so `index` only has\r\n     * to be consistent WITHIN a CommentType. The attachment form however defaults `index`\r\n     * to 1 for every new attachment, so a multi-image POI very often holds several images\r\n     * all sharing index 1 — or null. Sorting those is left to DynamoDB's arbitrary scan\r\n     * order, which is why the copy came out in a different order than the original.\r\n     *\r\n     * Strategy: sort deterministically (index, then creation date, then id — i.e. the\r\n     * upload order the user actually saw), and only rewrite the indices of a family when\r\n     * they are ambiguous (null or duplicated). A family whose indices are already unique\r\n     * is copied untouched, so a deliberate ordering is never overwritten.\r\n     */\r\n    private orderCommentsForCopy(comments: Comment[]): Comment[] {\r\n        const valid = (comments || []).filter(c => !!c);\r\n\r\n        const byType = new Map<string, Comment[]>();\r\n        for (const comment of valid) {\r\n            const key = (comment.type as string) || 'UNTYPED';\r\n            if (!byType.has(key)) {\r\n                byType.set(key, []);\r\n            }\r\n            byType.get(key).push(comment);\r\n        }\r\n\r\n        const ordered: Comment[] = [];\r\n\r\n        for (const family of byType.values()) {\r\n            family.sort((a, b) => {\r\n                const ai = this.orderingIndexOf(a);\r\n                const bi = this.orderingIndexOf(b);\r\n                if (ai !== bi) {\r\n                    return ai - bi;\r\n                }\r\n                const ad = this.creationTimeOf(a);\r\n                const bd = this.creationTimeOf(b);\r\n                if (ad !== bd) {\r\n                    return ad - bd;\r\n                }\r\n                return String((a as any).id || '').localeCompare(String((b as any).id || ''));\r\n            });\r\n\r\n            const indices = family.map(c => c.index);\r\n            const isAmbiguous = indices.some(i => i === null || i === undefined)\r\n                || new Set(indices).size !== indices.length;\r\n\r\n            family.forEach((comment, position) => {\r\n                (comment as any).__copyIndex = isAmbiguous ? position + 1 : comment.index;\r\n            });\r\n\r\n            ordered.push(...family);\r\n        }\r\n\r\n        return ordered;\r\n    }\r\n\r\n    /** Sort key for a comment's position; a missing index sorts last, not first. */\r\n    private orderingIndexOf(comment: Comment): number {\r\n        const index = comment?.index;\r\n        return index === null || index === undefined || Number.isNaN(Number(index))\r\n            ? Number.MAX_SAFE_INTEGER\r\n            : Number(index);\r\n    }\r\n\r\n    /** Creation timestamp of a comment, used as the tie-breaker: it reflects the order in\r\n     *  which the user uploaded the media, which is the order they saw. */\r\n    private creationTimeOf(comment: Comment): number {\r\n        const createdAt = (comment as any)?.createdAt;\r\n        if (!createdAt) {\r\n            return 0;\r\n        }\r\n        const time = new Date(createdAt).getTime();\r\n        return Number.isNaN(time) ? 0 : time;\r\n    }\r\n\r\n    /**\r\n     * Copies ONE media item (image, video, audio, document, text, link, embed, iframe...)\r\n     * of a feature, duplicating its file in S3 first when it has one.\r\n     *\r\n     * Every column of the Comment model is carried over. `description` and `metadata` were\r\n     * previously dropped, which emptied the captions of images/videos, the body of TEXT\r\n     * items — where the whole content lives, since a TEXT comment has no file — and any\r\n     * per-media settings stored in metadata.\r\n     */\r\n    private async copyCommentForFeature(\r\n        sourceComment: Comment,\r\n        targetFeatureId: string,\r\n        targetSpaceId: string\r\n    ): Promise<Comment> {\r\n        return this.copyComment(sourceComment, targetSpaceId, { featureID: targetFeatureId });\r\n    }\r\n\r\n    /** Same, for an attachment carried by a ticket rather than by a feature. */\r\n    private async copyCommentForTicket(\r\n        sourceComment: Comment,\r\n        targetTicketId: string,\r\n        targetSpaceId: string\r\n    ): Promise<Comment> {\r\n        return this.copyComment(sourceComment, targetSpaceId, { ticketID: targetTicketId });\r\n    }\r\n\r\n    /** Shared body of the two above: `owner` carries whichever foreign key links the copy back\r\n     *  to its new parent, everything else is identical. */\r\n    private async copyComment(\r\n        sourceComment: Comment,\r\n        targetSpaceId: string,\r\n        owner: { featureID?: string; ticketID?: string }\r\n    ): Promise<Comment> {\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, `attachment \"${rawComment.title}\"`);\r\n        }\r\n\r\n        const commentInput: any = {\r\n            title: rawComment.title,\r\n            description: rawComment.description ?? null,\r\n            metadata: rawComment.metadata ?? null,\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.__copyIndex ?? rawComment.index ?? null,\r\n            shownInTag: rawComment.shownInTag,\r\n            isCoverImage: rawComment.isCoverImage,\r\n            spaceID: targetSpaceId,\r\n            // Keeps crediting the ORIGINAL author when they also have a mission in the\r\n            // target space, and leaves the comment un-owned otherwise — see\r\n            // resolveCommentOwnerID(). Never the current operator's own mission: that\r\n            // would silently reassign authorship to whoever happens to run the copy.\r\n            ownerID: this.resolveCommentOwnerID(rawComment.ownerID),\r\n            ...owner\r\n        };\r\n\r\n        return this.commentService.createComment(commentInput);\r\n    }\r\n\r\n    //\r\n    // ---------- POI creation ----------\r\n    //\r\n\r\n    /**\r\n     * Creates the target-space copy of a source POI, with EVERY column of the POI model.\r\n     *\r\n     * Single entry point for all phases: the element phases (ticket, equipment, 3D object,\r\n     * feature, measurement) used to build their POI inline with only 5 fields — coordinate,\r\n     * type, elementID, metadata, sweep — which is precisely how museum POIs lost their\r\n     * pastille: `tagDescription` (the popup text), `tagIcon` (the custom icon) and\r\n     * `tagImageID` (the pastille's image) never left the source space.\r\n     */\r\n    private async createCopiedPoi(\r\n        sourcePoi: POI,\r\n        elementID: string | null,\r\n        sourceNavPositions: Map<string, Vec3>,\r\n        targetNavPositions: Map<string, Vec3>,\r\n        transform: RigidTransform\r\n    ): Promise<POI> {\r\n        const raw = sourcePoi as any;\r\n\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        const poiInput: any = {\r\n            coordinate: adjustedCoordinate === null || adjustedCoordinate === undefined\r\n                ? null\r\n                : JSON.stringify(adjustedCoordinate),\r\n            type: sourcePoi.type,\r\n            elementID: elementID ?? null,\r\n            matterportSweepID: targetSweepId,\r\n\r\n            // --- pastille (tag popup) ---\r\n            tagDescription: sourcePoi.tagDescription ?? null,\r\n            tagIcon: await this.duplicateTagIcon(sourcePoi.tagIcon),\r\n            tagImageID: this.resolveTagImageID(sourcePoi.tagImageID),\r\n\r\n            // --- rendering / visibility flags, carried over verbatim ---\r\n            specific: raw.specific ?? null,\r\n            private: raw.private ?? null,\r\n            global: raw.global ?? null,\r\n            level: raw.level ?? null,\r\n            role: raw.role ?? null,\r\n            category: raw.category ?? null,\r\n            domainID: this.resolveDomainID(raw.domainID),\r\n\r\n            // --- Matterport anchoring ---\r\n            metadata: this.getAdjustedPoiMetadata(sourcePoi.metadata, transform)\r\n        };\r\n\r\n        return this.poiService.createPOIForSpaceID(poiInput as POI);\r\n    }\r\n\r\n    /**\r\n     * Adapts a POI's `metadata` (see MattertagData.getMetadataString(): { icon, normal, sid })\r\n     * to the target space.\r\n     *\r\n     *  - `sid` is the id of the Mattertag inside the SOURCE Matterport model. Carried over,\r\n     *    the viewer tries to re-create the target's tag with an id belonging to another\r\n     *    model (\"already in use\"), so the pastille fails to attach. It is dropped: the\r\n     *    viewer then allocates a fresh sid on first render.\r\n     *  - `normal` is the stem direction. It is a direction, so only the rotation applies\r\n     *    (never the translation); without it, a copied pastille points into the wall\r\n     *    whenever the two models are not aligned on the same axis.\r\n     *  - `icon` and anything else is kept as-is.\r\n     */\r\n    private getAdjustedPoiMetadata(metadata: string | null | undefined, transform: RigidTransform): string | null {\r\n        if (!metadata) {\r\n            return metadata ?? null;\r\n        }\r\n        try {\r\n            const parsed = JSON.parse(metadata);\r\n            if (!parsed || typeof parsed !== 'object') {\r\n                return metadata;\r\n            }\r\n\r\n            if (parsed.normal\r\n                && typeof parsed.normal === 'object'\r\n                && typeof parsed.normal.x === 'number'\r\n                && typeof parsed.normal.y === 'number'\r\n                && typeof parsed.normal.z === 'number') {\r\n                parsed.normal = applyRigidTransformToDirection(parsed.normal, transform);\r\n            }\r\n\r\n            delete parsed.sid;\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 metadata;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Resolves a POI's `tagImageID` — which the schema documents as a \"connection to\r\n     * comment.id\", i.e. the id of the Comment holding the image shown in the pastille.\r\n     *\r\n     * It is NOT an S3 key, so the previous \"does it contain a slash?\" heuristic never\r\n     * matched and the value travelled unchanged, leaving every copied pastille pointing at\r\n     * a Comment of the source space. It is now translated through the comment id map built\r\n     * while duplicating the media, and dropped when it cannot be resolved (the pastille\r\n     * then falls back to the feature's cover image instead of a broken reference).\r\n     */\r\n    private resolveTagImageID(tagImageID: string | null | undefined): string | null {\r\n        if (!tagImageID) {\r\n            return null;\r\n        }\r\n        return this.commentIds.get(tagImageID) ?? null;\r\n    }\r\n\r\n    //\r\n    // ---------- Duplicate detection ----------\r\n    //\r\n\r\n    /**\r\n     * Heuristic duplicate-detection: compares several identifying fields together rather than\r\n     * a single label, to reduce false positives when items share one of them. Returns the\r\n     * matched target item (or undefined) rather than a boolean, so the caller can act on the\r\n     * existing record — heal its missing fields — instead of only skipping it.\r\n     *\r\n     * The fields are supplied by the caller because the models do not agree on them. The\r\n     * previous version hard-coded `title`/`description`, which do not exist on Equipment at\r\n     * all: both sides read `undefined`, every equipment therefore \"matched\" every other one,\r\n     * and a target space holding a single equipment silently caused the whole equipment phase\r\n     * to copy nothing.\r\n     */\r\n    private findExisting<T>(\r\n        source: T,\r\n        targetList: T[],\r\n        identity: (item: T) => Array<string | null | undefined>\r\n    ): T | undefined {\r\n        const sourceKey = this.identityKey(identity(source));\r\n        return targetList.find(target => this.identityKey(identity(target)) === sourceKey);\r\n    }\r\n\r\n    /**\r\n     * Builds a patch of whichever fields in `fields` the existing target record is missing\r\n     * (`null`/`undefined`/empty array) but the source has, plus `domainID` when requested —\r\n     * domains are organisation-scoped everywhere in this file, so that one is only ever\r\n     * healed across the SAME organisation, exactly like at creation time.\r\n     *\r\n     * Never overwrites a field the target already carries a value for: a value entered by\r\n     * hand in the target space since an earlier, incomplete copy must not be clobbered by\r\n     * an older or different source value.\r\n     *\r\n     * Returns both the patch to send and the list of healed field names, so the caller can\r\n     * both perform the update and describe it in the copy log.\r\n     */\r\n    private buildHealPatch(\r\n        sourceObj: any,\r\n        existingTarget: any,\r\n        fields: string[],\r\n        includeDomain: boolean\r\n    ): { patch: any; healedFields: string[] } {\r\n        const patch: any = {};\r\n        const healedFields: string[] = [];\r\n\r\n        const fillIfMissing = (key: string, sourceValue: any) => {\r\n            const currentValue = existingTarget[key];\r\n            const isMissing = currentValue === null || currentValue === undefined\r\n                || (Array.isArray(currentValue) && currentValue.length === 0);\r\n            if (isMissing && sourceValue !== null && sourceValue !== undefined) {\r\n                patch[key] = sourceValue;\r\n                healedFields.push(key);\r\n            }\r\n        };\r\n\r\n        for (const field of fields) {\r\n            fillIfMissing(field, sourceObj[field]);\r\n        }\r\n        if (includeDomain && (existingTarget.domainID === null || existingTarget.domainID === undefined)) {\r\n            const resolvedDomainId = this.resolveDomainID(sourceObj.domainID);\r\n            if (resolvedDomainId) {\r\n                patch.domainID = resolvedDomainId;\r\n                healedFields.push('domainID');\r\n            }\r\n        }\r\n\r\n        return { patch, healedFields };\r\n    }\r\n\r\n    /**\r\n     * Fills in whichever identity field a PRE-EXISTING target equipment is missing but the\r\n     * source has — see the call site in the EQUIPMENTS phase for why re-running the copy\r\n     * has to be able to repair a previously-copied equipment, not just skip it again.\r\n     *\r\n     * A failed update is left to bubble up to the caller's existing per-item try/catch, the\r\n     * same as a failed creation — it gets the same visible error line, rather than a silent\r\n     * console warning.\r\n     *\r\n     * Returns the list of fields that were actually healed (empty if nothing was missing).\r\n     */\r\n    private async healEquipmentIdentity(sourceObj: any, existingTarget: any): Promise<string[]> {\r\n        const { patch, healedFields } = this.buildHealPatch(\r\n            sourceObj, existingTarget,\r\n            ['status', 'annotation', 'family', 'sku', 'manufacturer', 'installDate', 'warrantyEndDate', 'metadata', 'isCreatedByAI'],\r\n            true\r\n        );\r\n\r\n        if (!existingTarget.photo && sourceObj.photo) {\r\n            patch.photo = await this.copyS3KeyIfPresent(sourceObj.photo, `equipment photo \"${sourceObj.name}\"`);\r\n            healedFields.push('photo');\r\n        }\r\n\r\n        if (healedFields.length === 0) {\r\n            return healedFields;\r\n        }\r\n\r\n        patch.id = existingTarget.id;\r\n        await this.equipmentService.updateEquipment(patch);\r\n        return healedFields;\r\n    }\r\n\r\n    /**\r\n     * Same idea as healEquipmentIdentity(), for a pre-existing ticket. `title`/`description`\r\n     * are the pair findExisting() matched on to find this ticket in the first place, so they\r\n     * are never part of the heal — by construction, they already agree with the source.\r\n     */\r\n    private async healTicketIdentity(sourceObj: any, existingTarget: any): Promise<string[]> {\r\n        const { patch, healedFields } = this.buildHealPatch(\r\n            sourceObj, existingTarget,\r\n            ['friendlyLabel', 'status', 'type', 'priority', 'level', 'metadata', 'read', 'projectID', 'problemCode'],\r\n            true\r\n        );\r\n\r\n        if (healedFields.length === 0) {\r\n            return healedFields;\r\n        }\r\n\r\n        patch.id = existingTarget.id;\r\n        await this.ticketService.updateTicket(patch);\r\n        return healedFields;\r\n    }\r\n\r\n    /** Same idea, for a pre-existing feature. Keywords, media and POIs are not healed here\r\n     *  for the same reason notes/POIs are not healed on equipment — see healEquipmentIdentity(). */\r\n    private async healFeatureIdentity(sourceObj: any, existingTarget: any): Promise<string[]> {\r\n        const { patch, healedFields } = this.buildHealPatch(\r\n            sourceObj, existingTarget,\r\n            ['shortDescription', 'level', 'type', 'index', 'stripeProductID', 'stripePriceID', 'bookingPriceMetadata', 'locale'],\r\n            true\r\n        );\r\n\r\n        if (healedFields.length === 0) {\r\n            return healedFields;\r\n        }\r\n\r\n        patch.id = existingTarget.id;\r\n        await this.featureService.updateFeature(patch);\r\n        return healedFields;\r\n    }\r\n\r\n    /** Serialises the identifying fields unambiguously, so that [\"a\", \"b\"] and [\"ab\", \"\"]\r\n     *  can never produce the same key. */\r\n    private identityKey(parts: Array<string | null | undefined>): string {\r\n        return JSON.stringify(parts.map(part => part ?? ''));\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     * Reads a stored coordinate (JSON string or object, whatever its spacing) as a position.\r\n     * Null for a virtual POI or an unreadable value.\r\n     */\r\n    private parseCoordinate(value: any): Vec3 | null {\r\n        try {\r\n            const parsed = typeof value === 'string' ? JSON.parse(value) : value;\r\n            return parsed && typeof parsed.x === 'number'\r\n                ? { x: parsed.x, y: parsed.y, z: parsed.z }\r\n                : null;\r\n        } catch {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /** Two positions within 1 cm are the same (two virtual POIs, both null, are too). */\r\n    private isSamePosition(a: Vec3 | null, b: Vec3 | null, toleranceM = 0.01): boolean {\r\n        if (!a || !b) {\r\n            return !a && !b;\r\n        }\r\n        return distance(a, b) <= toleranceM;\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     * `folderOverride` re-homes the copy into another prefix — used for tag icons, which\r\n     * are stored per space (`icons-tags/<spaceId>/`) and must follow the target space.\r\n     */\r\n    private buildCopiedAttachmentKey(sourceAnnexe: string, folderOverride: string | null = null): string {\r\n        const lastSlash = sourceAnnexe.lastIndexOf('/');\r\n        const folder = folderOverride ?? 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(\r\n        key: string | null | undefined,\r\n        contextLabel: string,\r\n        folderOverride: string | null = null\r\n    ): 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, folderOverride);\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            if (this.isMissingS3File(error)) {\r\n                console.warn(`[MatterportTagCopyService] Orphaned S3 reference, skipping item: \"${sourceKey}\" (${contextLabel})`);\r\n                throw new MissingS3FileError(sourceKey, contextLabel);\r\n            }\r\n\r\n            // Storage.copy() cannot handle a key holding a space, an accent or a parenthesis:\r\n            // it puts the key unencoded into `x-amz-copy-source`, which then disagrees with the\r\n            // signed request. Those files are perfectly readable — only that header is broken —\r\n            // so fall back to downloading and re-uploading them.\r\n            if (this.isSignatureMismatch(error)) {\r\n                console.warn(`[MatterportTagCopyService] Storage.copy() signature mismatch on \"${sourceKey}\", falling back to download + re-upload.`);\r\n                try {\r\n                    const copied = await copyFileInS3ViaDownload(sourceKey, destKey);\r\n                    if (!copied) {\r\n                        throw new MissingS3FileError(sourceKey, contextLabel);\r\n                    }\r\n                    return copied;\r\n                } catch (fallbackError: any) {\r\n                    if (this.isMissingS3File(fallbackError)) {\r\n                        throw new MissingS3FileError(sourceKey, contextLabel);\r\n                    }\r\n                    throw fallbackError;\r\n                }\r\n            }\r\n\r\n            throw error;\r\n        }\r\n    }\r\n\r\n    /** True when the failure means the source object simply is not on S3 (orphaned reference). */\r\n    private isMissingS3File(error: any): boolean {\r\n        return error instanceof MissingS3FileError\r\n            || error?.code === 'NoSuchKey'\r\n            || error?.name === 'NoSuchKey'\r\n            || /NoSuchKey|does not exist|NotFound/i.test(toErrorMessage(error));\r\n    }\r\n\r\n    /** True when AppSync refused the operation for lack of permission, as opposed to failing it.\r\n     *  Nothing can be retried or worked around client-side: the account simply is not allowed\r\n     *  to write that model, which is a backend authorisation rule (@auth) to change. */\r\n    private isUnauthorized(error: any): boolean {\r\n        const message = toErrorMessage(error);\r\n        return error?.errorType === 'Unauthorized'\r\n            || /Unauthorized|Not Authorized to access/i.test(message);\r\n    }\r\n\r\n    /** True for the SigV4 mismatch Storage.copy() raises on keys with special characters. */\r\n    private isSignatureMismatch(error: any): boolean {\r\n        return error?.code === 'SignatureDoesNotMatch'\r\n            || error?.name === 'SignatureDoesNotMatch'\r\n            || /signature we calculated does not match|SignatureDoesNotMatch/i.test(toErrorMessage(error));\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).\r\n     *\r\n     * Two behaviours matter here:\r\n     *  - the copy is re-homed under the TARGET space's icon folder\r\n     *    (`icons-tags/<targetSpaceId>/`, the layout form-feature.component.ts uploads to).\r\n     *    Keeping the source folder produced a target space whose icons all lived under\r\n     *    another space's prefix, so cleaning up the source space broke the copy's icons.\r\n     *  - a missing icon file is NOT fatal. It used to bubble up as a MissingS3FileError and\r\n     *    abort the whole POI — losing the pastille, its text and its media because of a\r\n     *    decorative file. The POI is now created with the icon reference dropped, which\r\n     *    renders the module's default icon, and a log line reports it.\r\n     */\r\n    private async duplicateTagIcon(tagIconRaw: string | null | undefined): Promise<string | null | undefined> {\r\n        if (!tagIconRaw) {\r\n            return tagIconRaw ?? null;\r\n        }\r\n\r\n        let parsed: any;\r\n        try {\r\n            parsed = JSON.parse(tagIconRaw);\r\n        } catch {\r\n            // Not JSON — leave untouched rather than guess.\r\n            return tagIconRaw;\r\n        }\r\n\r\n        if (!parsed || typeof parsed !== 'object' || !parsed.src) {\r\n            return tagIconRaw;\r\n        }\r\n\r\n        try {\r\n            parsed.src = await this.copyS3KeyIfPresent(\r\n                parsed.src, 'tag icon', this.buildTargetIconFolder()\r\n            );\r\n        } catch (iconError) {\r\n            if (!(iconError instanceof MissingS3FileError)) {\r\n                // A real failure (permissions, network, ...) still aborts the POI: it means\r\n                // the copy cannot be trusted, unlike a file that is simply already gone.\r\n                throw iconError;\r\n            }\r\n            console.warn(`[MatterportTagCopyService] Tag icon missing on S3, falling back to the default icon: \"${iconError.sourceKey}\"`);\r\n            this.logItemError('warningTagIconMissing', { file: iconError.sourceKey });\r\n            delete parsed.src;\r\n        }\r\n\r\n        return JSON.stringify(parsed);\r\n    }\r\n\r\n    /** Icon folder of the space being copied into, matching what the feature form uploads to. */\r\n    private buildTargetIconFolder(): string | null {\r\n        return this.targetSpaceId ? `icons-tags/${this.targetSpaceId}/` : null;\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\r\n    /**\r\n     * Both tag lists a recalibration can offer for a target space, computed in one pass. Only\r\n     * the target location's own tags are ever listed (see RecalibrationTagScope); tags whose\r\n     * element was deleted — orphan POIs — never are.\r\n     *  - `space`: every tag of the location, in any of its visits;\r\n     *  - `visit`: the tags of the location sitting on the sweeps of the selected target visit\r\n     *    (`options.targetNodeId`); empty when no visit is given.\r\n     * With `options.onlyTagsInSource` and a source other than the target, both lists only keep\r\n     * the tags that also exist in the source location (same identity as the copy's duplicate\r\n     * detection): typically the tags an earlier copy brought over.\r\n     *\r\n     * A POI carries no name of its own: each tag gets `elementName`, the name of the element\r\n     * it points at (ticket title, equipment name, ...).\r\n     */\r\n    async getRecalibrationTagSets(\r\n        sourceSpaceId: string,\r\n        targetSpaceId: string,\r\n        options: RecalibrationTagOptions = {}\r\n    ): Promise<RecalibrationTagSets> {\r\n        if (!sourceSpaceId || !targetSpaceId) {\r\n            return { space: [], visit: [] };\r\n        }\r\n        const filterBySource = !!options.onlyTagsInSource && sourceSpaceId !== targetSpaceId;\r\n        const [targetTags, sourceTags] = await Promise.all([\r\n            this.loadLiveTagsForSpace(targetSpaceId, options.targetNodeId),\r\n            filterBySource ? this.loadLiveTagsForSpace(sourceSpaceId) : Promise.resolve(null)\r\n        ]);\r\n\r\n        const sourceKeys = sourceTags && new Set(sourceTags.filter(tag => tag.ownedBySpace).map(tag => tag.identity));\r\n        const ownTargetTags = targetTags\r\n            .filter(tag => tag.ownedBySpace)\r\n            .filter(tag => !sourceKeys || sourceKeys.has(tag.identity));\r\n        return {\r\n            space: ownTargetTags.map(tag => tag.poi),\r\n            visit: ownTargetTags.filter(tag => tag.inVisit).map(tag => tag.poi)\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Signed, displayable URL of a tag's picture (`elementImageKey`). Meant to be called on\r\n     * demand — when the tag is previewed — rather than for the whole list.\r\n     */\r\n    async getTagImageUrl(imageKey: string): Promise<string | null> {\r\n        const key = this.extractS3KeyFromValue(imageKey);\r\n        return key ? getSignedFile(key) : null;\r\n    }\r\n\r\n    /**\r\n     * Loads the POIs placed on the sweeps of a space whose element still exists, each with a\r\n     * display name, an identity key and whether its element belongs to that space. The key\r\n     * follows the same rules as the copy's duplicate detection (findExisting), so a tag and its\r\n     * copy in another space share the same key. With a visit node, `inVisit` tells whether the\r\n     * tag sits on one of that visit's sweeps.\r\n     */\r\n    private async loadLiveTagsForSpace(\r\n        spaceId: string,\r\n        visitNodeId?: string | null\r\n    ): Promise<{ poi: RecalibrationTag; identity: string; ownedBySpace: boolean; inVisit: boolean }[]> {\r\n        const [pois, elements, zones] = await Promise.all([\r\n            this.navigationService.getAllowedSweepsIDsForUserInSpace(spaceId)\r\n                .then(sweepIds => this.poiService.getPoisByMatterportSweeps(sweepIds)),\r\n            this.getTagElementsForSpace(spaceId),\r\n            this.zoneService.getZonesBySpace(spaceId).catch(error => {\r\n                console.error('Failed to load the zones of the space:', error);\r\n                return [] as any[];\r\n            })\r\n        ]);\r\n        const sweepZones = this.getSweepZones(zones || []);\r\n        const visitSweeps = visitNodeId ? await this.getSweepsOfVisit(visitNodeId, zones || []) : new Set<string>();\r\n\r\n        // A POI can point at an element stored under another space (left behind by an earlier\r\n        // copy): those are not in the space-wide lists and are fetched by ID.\r\n        const unresolved = (pois || []).filter(poi => poi?.elementID && !elements.has(poi.elementID));\r\n        await this.fetchTagElementsById(unresolved, elements);\r\n\r\n        const result: { poi: RecalibrationTag; identity: string; ownedBySpace: boolean; inVisit: boolean }[] = [];\r\n        for (const poi of pois || []) {\r\n            if (!poi) {\r\n                continue;\r\n            }\r\n            let element: TagElement | undefined;\r\n            if (poi.elementID) {\r\n                element = elements.get(poi.elementID);\r\n                if (!element) {\r\n                    continue; // orphan: the element was deleted (or cannot be read)\r\n                }\r\n            } else {\r\n                // standalone tag: its description is all that identifies it\r\n                const description = this.stripHtml(poi.tagDescription);\r\n                element = { name: description, identity: [description] };\r\n            }\r\n            const zones = sweepZones.get(poi.matterportSweepID as string);\r\n            result.push({\r\n                poi: {\r\n                    ...poi,\r\n                    elementName: element.name,\r\n                    elementDescription: element.description,\r\n                    elementImageKey: element.imageKey,\r\n                    floorName: zones?.floor,\r\n                    zoneName: zones?.zone\r\n                },\r\n                identity: this.identityKey([poi.type, ...element.identity]),\r\n                // decided by the element's own spaceID rather than by its presence in the\r\n                // space-wide lists, some of which are not paginated. A standalone tag has no\r\n                // element to tell: it belongs to every space that shows it.\r\n                ownedBySpace: !poi.elementID || element.spaceId === spaceId,\r\n                inVisit: visitSweeps.has(poi.matterportSweepID as string)\r\n            });\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Sweeps of a virtual visit (a Node): those of the space's zones attached to that node,\r\n     * else — zones not filled in for this visit — the sweeps of the node's navigations.\r\n     */\r\n    private async getSweepsOfVisit(nodeId: string, zones: any[]): Promise<Set<string>> {\r\n        const sweeps = new Set<string>(zones\r\n            .filter(zone => zone.nodeIDs?.includes(nodeId))\r\n            .flatMap(zone => zone.sweepIDs || []));\r\n        if (sweeps.size === 0) {\r\n            try {\r\n                const navigations = await this.navigationService.getNavigationsForNode(nodeId);\r\n                navigations.forEach(navigation => navigation.matterportSweepID && sweeps.add(navigation.matterportSweepID));\r\n            } catch (error) {\r\n                console.error('Failed to load the sweeps of the visit:', error);\r\n            }\r\n        }\r\n        return sweeps;\r\n    }\r\n\r\n    /**\r\n     * Maps each sweep of a space to the names of its floor (zone of layer FLOOR) and of its\r\n     * most specific other zone (the one holding the fewest sweeps, typically a room, else the\r\n     * visit's BUILDING zone).\r\n     */\r\n    private getSweepZones(zones: any[]): Map<string, { floor?: string; zone?: string }> {\r\n        const bySweep = new Map<string, { floor?: string; zone?: string }>();\r\n        const isFloor = (zone: any) => (zone.layer?.name || '').includes('FLOOR');\r\n        const zoneRank = new Map<string, number>(); // sweep -> sweep count of the zone kept so far\r\n        for (const zone of zones) {\r\n            for (const sweepId of zone.sweepIDs || []) {\r\n                const entry = bySweep.get(sweepId) || {};\r\n                if (isFloor(zone)) {\r\n                    entry.floor = entry.floor || zone.name;\r\n                } else {\r\n                    const size = zone.sweepIDs.length;\r\n                    if (!zoneRank.has(sweepId) || size < (zoneRank.get(sweepId) as number)) {\r\n                        zoneRank.set(sweepId, size);\r\n                        entry.zone = zone.name;\r\n                    }\r\n                }\r\n                bySweep.set(sweepId, entry);\r\n            }\r\n        }\r\n        return bySweep;\r\n    }\r\n\r\n    /**\r\n     * Indexes, by ID, every element of a space a POI can point at. Each list is fetched\r\n     * independently: one failing (module not enabled, missing permission) must not hide the\r\n     * others — their POIs are then resolved one by one by fetchTagElementsById().\r\n     */\r\n    private async getTagElementsForSpace(spaceId: string): Promise<Map<string, TagElement>> {\r\n        const elements = new Map<string, TagElement>();\r\n        const [tickets, equipments, objects3D, features, comments] = await Promise.allSettled([\r\n            this.ticketService.getTicketsBySpace(spaceId),\r\n            this.equipmentService.getEquipmentsForSpace(spaceId),\r\n            this.object3DService.getObjects3DBySpace(spaceId),\r\n            this.featureService.getAllFeaturesBySpaceRaw(spaceId),\r\n            // a measurement POI is bound to the measurement's Comment, not to the measurement\r\n            this.commentService.getCommentsBySpaceID(spaceId)\r\n        ]);\r\n\r\n        const index = (settled: PromiseSettledResult<any[]>, type: TagElementType) => {\r\n            if (settled.status === 'fulfilled') {\r\n                settled.value?.forEach(item => {\r\n                    if (item?.id) {\r\n                        elements.set(item.id, this.toTagElement(type, { spaceID: spaceId, ...item }));\r\n                    }\r\n                });\r\n            }\r\n        };\r\n        index(tickets, 'ticket');\r\n        index(equipments, 'equipment');\r\n        index(objects3D, 'object3D');\r\n        index(features, 'feature');\r\n        index(comments, 'comment');\r\n        return elements;\r\n    }\r\n\r\n    /**\r\n     * Fetches by ID the elements the space-wide lists did not return. The IDs are packed into\r\n     * a few GraphQL requests using aliases (`e0: getTicket(id: ...) e1: getEquipment(...)`),\r\n     * instead of one request per element: a space can hold over a thousand orphan POIs.\r\n     * An element that no longer exists comes back as null and is simply not indexed.\r\n     */\r\n    private async fetchTagElementsById(pois: POI[], elements: Map<string, TagElement>): Promise<void> {\r\n        const IDS_PER_REQUEST = 100;\r\n        const queries: Record<TagElementType, string> = {\r\n            ticket: 'getTicket(id: $ID) { id spaceID title description }',\r\n            equipment: 'getEquipment(id: $ID) { id spaceID name serialNumber }',\r\n            object3D: 'getObject3D(id: $ID) { id spaceID name description }',\r\n            comment: 'getComment(id: $ID) { id spaceID title description annexe }',\r\n            feature: 'getFeature(id: $ID) { id spaceID title description }'\r\n        };\r\n\r\n        const pending = new Map<string, TagElementType>();\r\n        for (const poi of pois) {\r\n            pending.set(poi.elementID as string, this.tagElementTypeOf(poi.type));\r\n        }\r\n        const entries = [...pending.entries()];\r\n        const batches: [string, TagElementType][][] = [];\r\n        for (let i = 0; i < entries.length; i += IDS_PER_REQUEST) {\r\n            batches.push(entries.slice(i, i + IDS_PER_REQUEST));\r\n        }\r\n\r\n        await Promise.all(batches.map(async batch => {\r\n            const fields = batch.map(([id, type], i) =>\r\n                `e${i}: ${queries[type].replace('$ID', JSON.stringify(id))}`);\r\n            let data: any;\r\n            try {\r\n                data = ((await API.graphql(graphqlOperation(`query TagElements { ${fields.join('\\n')} }`))) as any).data;\r\n            } catch (error: any) {\r\n                // Amplify rejects when ANY alias errors (e.g. an unreadable record), but still\r\n                // hands over the data of the aliases that succeeded.\r\n                data = error?.data;\r\n                if (!data) {\r\n                    console.error('Failed to fetch tag elements by ID:', error);\r\n                    return;\r\n                }\r\n            }\r\n            batch.forEach(([id, type], i) => {\r\n                const item = data[`e${i}`];\r\n                if (item) {\r\n                    elements.set(id, this.toTagElement(type, item));\r\n                }\r\n            });\r\n        }));\r\n    }\r\n\r\n    /**\r\n     * Moves a stored coordinate. Only the position and the horizontal orientation change:\r\n     * every other key is kept as is. A coordinate often carries the tag's orientation next to\r\n     * its position ({x, y, z, xRotation, yRotation}); rebuilding it from the position alone\r\n     * silently erased that orientation.\r\n     */\r\n    private getRecalibratedCoordinate(coordinate: any, transform: RigidTransform): any {\r\n        const position = applyRigidTransformToPoint(\r\n            { x: coordinate.x, y: coordinate.y, z: coordinate.z }, transform);\r\n        const moved: any = { ...coordinate, x: position.x, y: position.y, z: position.z };\r\n        if ('yRotation' in coordinate) {\r\n            moved.yRotation = applyRigidTransformToYRotationDeg(coordinate.yRotation, transform);\r\n        }\r\n        return moved;\r\n    }\r\n\r\n    /**\r\n     * Reads POIs by ID, 100 per GraphQL request (aliases). Missing POIs are skipped. Amplify\r\n     * rejects a request when ANY alias errors, but still hands over the data of the others:\r\n     * those are kept, so one unreadable POI does not hide the 99 others of its batch.\r\n     */\r\n    private async fetchPoisById(ids: string[]): Promise<POI[]> {\r\n        const IDS_PER_REQUEST = 100;\r\n        const uniqueIds = [...new Set(ids)];\r\n        const batches: string[][] = [];\r\n        for (let i = 0; i < uniqueIds.length; i += IDS_PER_REQUEST) {\r\n            batches.push(uniqueIds.slice(i, i + IDS_PER_REQUEST));\r\n        }\r\n\r\n        const results = await Promise.all(batches.map(async batch => {\r\n            const fields = batch.map((id, i) => `p${i}: getPOI(id: ${JSON.stringify(id)}) { id coordinate metadata }`);\r\n            let data: any;\r\n            try {\r\n                data = ((await API.graphql(graphqlOperation(`query SelectedPois { ${fields.join('\\n')} }`))) as any).data;\r\n            } catch (error: any) {\r\n                data = error?.data;\r\n                if (!data) {\r\n                    console.error('Failed to read the selected POIs:', error);\r\n                    return [];\r\n                }\r\n            }\r\n            return batch.map((_, i) => data[`p${i}`] as POI).filter(poi => !!poi);\r\n        }));\r\n        return results.flat();\r\n    }\r\n\r\n    private tagElementTypeOf(poiType: PoiType | null | undefined): TagElementType {\r\n        switch (poiType) {\r\n            case PoiType.TICKET: return 'ticket';\r\n            case PoiType.EQUIPMENT: return 'equipment';\r\n            case PoiType.OBJECT3D: return 'object3D';\r\n            case PoiType.MEASURE: return 'comment';\r\n            default: return 'feature';\r\n        }\r\n    }\r\n\r\n    /** Display name + identity fields of an element, per the copy's duplicate-detection rules. */\r\n    private toTagElement(type: TagElementType, item: any): TagElement {\r\n        const spaceId = item.spaceID;\r\n        const text = (value: string | null | undefined) => this.stripHtml(value) || undefined;\r\n        switch (type) {\r\n            case 'equipment':\r\n                return { name: item.name || '', identity: [item.name, item.serialNumber], spaceId, description: text(item.description) };\r\n            case 'object3D':\r\n                return { name: item.name || '', identity: [item.name], spaceId, description: text(item.description) };\r\n            case 'comment':\r\n                // A measurement's title is usually empty: its description holds the dimensions and\r\n                // becomes the name. Its picture is the screenshot taken when it was measured.\r\n                return {\r\n                    name: item.title || item.description || '',\r\n                    identity: [item.title, item.description],\r\n                    spaceId,\r\n                    description: item.title ? text(item.description) : undefined,\r\n                    imageKey: item.annexe || undefined\r\n                };\r\n            default:\r\n                return { name: item.title || '', identity: [item.title, item.description], spaceId, description: text(item.description) };\r\n        }\r\n    }\r\n\r\n    private stripHtml(value: string | null | undefined): string {\r\n        return (value || '').replace(/<[^>]*>/g, ' ').replace(/\\s+/g, ' ').trim();\r\n    }\r\n\r\n    /**\r\n     * Recalibrates a specific list of existing tags in the target space by applying the rigid\r\n     * transformation calculated from the selected landmark points.\r\n     *\r\n     * Each tag is updated on its own: a failing update is logged and counted, it no longer\r\n     * stops the remaining tags. Progress and log go through copyProgress$ / copyLog$, like a\r\n     * copy (phase 'recalibrating'). `tagLabels` (tag id -> name) only makes the log readable.\r\n     */\r\n    async recalibrateTagsFromVisit(\r\n        targetSpaceId: string,\r\n        selectedTagIds: string[],\r\n        landmarkSourceA: Vec3,\r\n        landmarkTargetA: Vec3,\r\n        landmarkSourceB: Vec3,\r\n        landmarkTargetB: Vec3,\r\n        tagLabels: Record<string, string> = {}\r\n    ): Promise<RecalibrationResult> {\r\n        const result: RecalibrationResult = { updated: 0, skipped: 0, failed: 0 };\r\n        const uniqueIds = [...new Set(selectedTagIds)];\r\n        const total = uniqueIds.length;\r\n        const label = (id: string) => tagLabels[id] || `#${id.substring(0, 8)}`;\r\n        let processed = 0;\r\n        const emitProgress = (phase: CopyProgress['phase']) => {\r\n            this.copyProgress$.next({\r\n                phase,\r\n                processedInPhase: processed, totalInPhase: total,\r\n                processedOverall: processed, totalOverall: total,\r\n                percent: total > 0 ? Math.round((processed / total) * 100) : 100,\r\n                errorCount: result.failed, healedCount: 0\r\n            });\r\n            this.setStepLog('recalibrating', this.translate.instant('matterportCopy.recalibrateStep',\r\n                { processed, total }));\r\n        };\r\n\r\n        this.resetLog();\r\n        emitProgress('recalibrating');\r\n        try {\r\n            const transform = computeRigidTransform(\r\n                landmarkSourceA, landmarkTargetA,\r\n                landmarkSourceB, landmarkTargetB\r\n            );\r\n\r\n            // Re-read only the selected POIs, by ID, so the transform is applied to their current\r\n            // position — scanning the whole space again for a handful of tags was the slow path.\r\n            const targetPois = await this.fetchPoisById(uniqueIds);\r\n            const foundIds = new Set(targetPois.map(poi => poi.id));\r\n            uniqueIds.filter(id => !foundIds.has(id)).forEach(id => {\r\n                result.skipped++;\r\n                processed++;\r\n                this.appendErrorLog(this.translate.instant('matterportCopy.recalibrateNotFound', { name: label(id) }));\r\n            });\r\n            emitProgress('recalibrating');\r\n\r\n            const UPDATES_IN_PARALLEL = 10;\r\n            for (let i = 0; i < targetPois.length; i += UPDATES_IN_PARALLEL) {\r\n                await Promise.all(targetPois.slice(i, i + UPDATES_IN_PARALLEL).map(async poi => {\r\n                    const id = poi.id as string;\r\n                    try {\r\n                        let originalCoord: any = null;\r\n                        try {\r\n                            originalCoord = typeof poi.coordinate === 'string'\r\n                                ? JSON.parse(poi.coordinate)\r\n                                : poi.coordinate;\r\n                        } catch {\r\n                            originalCoord = null;\r\n                        }\r\n                        if (!originalCoord || typeof originalCoord.x !== 'number') {\r\n                            // virtual POI or unreadable coordinate: no position to move\r\n                            result.skipped++;\r\n                            this.appendErrorLog(this.translate.instant('matterportCopy.recalibrateSkipped', { name: label(id) }));\r\n                            return;\r\n                        }\r\n\r\n                        await this.poiService.updatePoi({\r\n                            id,\r\n                            coordinate: JSON.stringify(this.getRecalibratedCoordinate(originalCoord, transform)),\r\n                            metadata: this.getAdjustedPoiMetadata(poi.metadata, transform)\r\n                        });\r\n                        result.updated++;\r\n                    } catch (error) {\r\n                        result.failed++;\r\n                        console.error(`Failed to recalibrate the tag ${id}:`, error);\r\n                        this.appendErrorLog(this.translate.instant('matterportCopy.recalibrateError',\r\n                            { name: label(id), error: toErrorMessage(error) }));\r\n                    } finally {\r\n                        processed++;\r\n                        emitProgress('recalibrating');\r\n                    }\r\n                }));\r\n            }\r\n        } catch (error) {\r\n            // transform or reading failure: nothing left can be moved\r\n            console.error('Erreur lors du recalibrage des tags:', error);\r\n            result.failed = total - result.updated - result.skipped;\r\n            processed = total;\r\n            this.appendErrorLog(this.translate.instant('matterportCopy.errorGeneral', { error: toErrorMessage(error) }));\r\n        }\r\n\r\n        emitProgress('done');\r\n        this.setStepLog('done', this.translate.instant('matterportCopy.recalibrateSummary', result));\r\n        return result;\r\n    }\r\n}"]}