@smarterplan/ngx-smarterplan-core 1.4.16 → 1.4.18

package/lib/mattertagData.d.ts

@@ -52,6 +52,10 @@ export declare class MattertagData {
             b: number;
         };
     };
+    /**
+     * Safely retrieves the display name depending on object properties (name, title)
+     */
+    getDisplayName(): string;
     /**
      * Get the descriptor for sdk.Tag.add(...descriptor)
      * Format : [{ label, description, anchorPosition, stemVector, color, id? }]

package/lib/services/matterport-tag-copy.service.d.ts

@@ -1,5 +1,6 @@
 import { BehaviorSubject } from 'rxjs';
 import { TranslateService } from '@ngx-translate/core';
+import { POI } from '../types.service';
 import { NavigationService } from './models/navigation.service';
 import { PoiService } from './models/poi.service';
 import { TicketsService } from './models/ticket.service';
@@ -12,12 +13,13 @@ import { HashtagService } from './models/hashtag.service';
 import { MissionService } from './models/mission.service';
 import { OperationService } from './models/operation.service';
 import { DomainService } from './models/domain.service';
+import { ZoneService } from './models/zone.service';
 import { BaseUserService } from './user.service';
 import { Vec3 } from './utils/matterport-transform.util';
 import * as i0 from "@angular/core";
 /** Progress snapshot emitted during copyTagsFromVisit(), so the UI can show a live status. */
 export interface CopyProgress {
-    phase: 'collecting' | 'tickets' | 'equipments' | 'pois' | 'objects3d' | 'features' | 'measurements' | 'done';
+    phase: 'collecting' | 'tickets' | 'equipments' | 'pois' | 'objects3d' | 'features' | 'measurements' | 'recalibrating' | 'done';
     processedInPhase: number;
     totalInPhase: number;
     processedOverall: number;
@@ -36,6 +38,44 @@ export interface CopyLogEntry {
     type: 'step' | 'error' | 'healed';
     text: string;
 }
+/** A tag listed for recalibration, with what the UI needs to identify it. */
+export type RecalibrationTag = POI & {
+    elementName: string;
+    elementDescription?: string;
+    /** pass to getTagImageUrl() to get a displayable (signed) URL */
+    elementImageKey?: string;
+    /** floor zone (layer FLOOR) of the tag's sweep in the target space */
+    floorName?: string;
+    /** most specific other zone of the tag's sweep in the target space */
+    zoneName?: string;
+};
+/**
+ * Which tags of a space (location) a recalibration lists. A tag belongs to a location (the
+ * space of the element it points at; a standalone tag belongs to every location showing it)
+ * and is displayed in one or several virtual visits of that location. Tags of another
+ * location are never listed, even when both locations use the same visit.
+ *  - SPACE: every tag of the location, whichever of its visits it sits in;
+ *  - VISIT: the tags of the location placed on the sweeps of the selected visit.
+ */
+export type RecalibrationTagScope = 'SPACE' | 'VISIT';
+/** Both lists getRecalibrationTagSets() offers, see there. */
+export interface RecalibrationTagSets {
+    space: RecalibrationTag[];
+    visit: RecalibrationTag[];
+}
+export interface RecalibrationTagOptions {
+    /** Node of the selected target visit (visit.node.id): drives the VISIT list. */
+    targetNodeId?: string | null;
+    /** Only keep the tags that also exist in the source location (ignored when source = target). */
+    onlyTagsInSource?: boolean;
+}
+/** Outcome of recalibrateTagsFromVisit(): how many of the selected tags were moved. */
+export interface RecalibrationResult {
+    updated: number;
+    /** selected tags not found anymore, or without a position to move */
+    skipped: number;
+    failed: number;
+}
 export declare class MatterportTagCopyService {
     private navigationService;
     private userService;
@@ -51,6 +91,7 @@ export declare class MatterportTagCopyService {
     private operationService;
     private domainService;
     private translate;
+    private zoneService;
     copyProgress$: BehaviorSubject<CopyProgress | null>;
     copyLog$: BehaviorSubject<CopyLogEntry[]>;
     private spModule;
@@ -91,7 +132,7 @@ export declare class MatterportTagCopyService {
     private targetDomainIdsByTypeAndName;
     /** Target space id of the run in progress — used to re-home copied tag icons. */
     private targetSpaceId;
-    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, hashtagService: HashtagService, missionService: MissionService, operationService: OperationService, domainService: DomainService, translate: TranslateService);
+    constructor(navigationService: NavigationService, userService: BaseUserService, poiService: PoiService, ticketService: TicketsService, equipmentService: EquipmentService, object3DService: Object3DService, featureService: FeatureService, measurementService: MeasurementService, commentService: CommentService, hashtagService: HashtagService, missionService: MissionService, operationService: OperationService, domainService: DomainService, translate: TranslateService, zoneService: ZoneService);
     copyTagsFromVisit(sourceSpaceId: string, targetSpaceId: string, landmarkSourceA: Vec3, landmarkTargetA: Vec3, landmarkSourceB: Vec3, landmarkTargetB: Vec3): Promise<boolean>;
     /**
      * Serialises the current copy log (step lines as last emitted, plus every error and
@@ -362,6 +403,13 @@ export declare class MatterportTagCopyService {
     private buildNavigationPositionMap;
     /** Applies the rigid transform to a POI coordinate (position + orientation). */
     private getAdjustedCoordinates;
+    /**
+     * Reads a stored coordinate (JSON string or object, whatever its spacing) as a position.
+     * Null for a virtual POI or an unreadable value.
+     */
+    private parseCoordinate;
+    /** Two positions within 1 cm are the same (two virtual POIs, both null, are too). */
+    private isSamePosition;
     /**
      * Applies the rigid transform's translation+rotation to a plain {x,y,z} position,
      * WITHOUT adding xRotation/yRotation keys. Used for measurements, whose stored
@@ -425,6 +473,84 @@ export declare class MatterportTagCopyService {
      * existed on S3, resulting in a NoSuchKey error.
      */
     private extractS3KeyFromValue;
+    /**
+     * 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, ...).
+     */
+    getRecalibrationTagSets(sourceSpaceId: string, targetSpaceId: string, options?: RecalibrationTagOptions): Promise<RecalibrationTagSets>;
+    /**
+     * 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.
+     */
+    getTagImageUrl(imageKey: string): Promise<string | 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.
+     */
+    private loadLiveTagsForSpace;
+    /**
+     * 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.
+     */
+    private getSweepsOfVisit;
+    /**
+     * 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).
+     */
+    private getSweepZones;
+    /**
+     * 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().
+     */
+    private getTagElementsForSpace;
+    /**
+     * 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.
+     */
+    private fetchTagElementsById;
+    /**
+     * 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.
+     */
+    private getRecalibratedCoordinate;
+    /**
+     * 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.
+     */
+    private fetchPoisById;
+    private tagElementTypeOf;
+    /** Display name + identity fields of an element, per the copy's duplicate-detection rules. */
+    private toTagElement;
+    private stripHtml;
+    /**
+     * 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.
+     */
+    recalibrateTagsFromVisit(targetSpaceId: string, selectedTagIds: string[], landmarkSourceA: Vec3, landmarkTargetA: Vec3, landmarkSourceB: Vec3, landmarkTargetB: Vec3, tagLabels?: Record<string, string>): Promise<RecalibrationResult>;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatterportTagCopyService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MatterportTagCopyService>;
 }

package/lib/services/matterport-tag.service.d.ts

@@ -18,6 +18,13 @@ export declare class MatterportTagService {
     tagService: BaseTagService | null;
     private tagsCurrentOpacity;
     private tagsCurrentEnabled;
+    /** tagId -> icon name last applied, so an unchanged icon is not re-applied. */
+    private tagsCurrentIcon;
+    /** Ids of the global SDK Tag collection, and the tags waiting to appear in it, see waitForTagInSdk(). */
+    private sdkTagIds;
+    private sdkTagWaiters;
+    private sdkTagSubscription;
+    private sdkTagSubscriptionSdk;
     /**
      * Single layer holding every Smarterplan tag, added to every view of the space so a
      * tag stays in place — same sid, same content — when the user switches between the
@@ -45,9 +52,25 @@ export declare class MatterportTagService {
      * A layer-scoped Tag module only exposes the *replayable* mutations, meant to build
      * the layer's own content; applying them to an already-created tag silently does
      * nothing — which is what left every pin white instead of carrying its icon. Only
-     * `add` has to go through the layer, see getTagCreationModule().
+     * `add` has to go through the layer, see getTagCreationModule(). The global module
+     * only knows a layer-created pin once it is rendered: see waitForTagInSdk().
      */
     getTagModule(sdk: any, tagId: string): any;
+    /** Icon name last applied to a tag, if any. */
+    getCachedTagIcon(tagId: string): string | undefined;
+    /** Applies an icon to a tag through its own module and remembers it on success. */
+    editTagIcon(sdk: any, tagId: string, iconName: string): Promise<void>;
+    /**
+     * Resolves once the global SDK Tag collection — the one edits go through — contains the
+     * tag, so edits do not hit a pin that is not rendered yet ("setPinRenderOverrides on a pin
+     * that doesn't exist"). Gives up after `timeoutMs` and resolves anyway; falls back to a
+     * short wait when the collection cannot be observed. One subscription is shared by every
+     * waiting tag: a space loads hundreds of them.
+     */
+    private waitForTagInSdk;
+    /** Keeps sdkTagIds in sync with the global SDK Tag collection; false when it cannot be observed. */
+    private observeSdkTags;
+    private stopObservingSdkTags;
     /**
      * Returns the Tag module every new tag must be created through: the shared layer
      * when the View API is available, the global sdk.Tag otherwise.

package/lib/services/matterport.service.d.ts

@@ -106,6 +106,12 @@ export declare class MatterportService {
     }>;
     /** Views (furnished, defurnished...) exposed by the SDK for the current space. */
     private viewsByType;
+    /** Settles once every static icon texture has been registered (or failed). */
+    private iconsRegistered;
+    /** Names of the textures successfully registered in the current SDK session. */
+    private registeredIcons;
+    /** tagId -> signed source last registered as a custom texture, and its texture name. */
+    private customIconCache;
     private currentView;
     private viewSubscriptions;
     /** Emits the active view every time the user switches between furnished/defurnished. */
@@ -193,11 +199,14 @@ export declare class MatterportService {
     addNewIconAndSetForTag(mattertagID: string, iconPath: string): Promise<void>;
     /** Applies a pre-registered icon to a Mattertag. */
     setRegistredIconForTag(mattertagID: string, iconName: string): Promise<void>;
-    /** Sets the appropriate icon and opacity for a tag based on its type and POI metadata. */
+    /** Registers a static texture and remembers its name once the SDK accepted it. */
+    private registerIcon;
+    /** Sets the appropriate icon for a tag based on its type and POI metadata. */
     setTagIconAndOpacity(mattertagID: string, mattertagData: MattertagData): Promise<void>;
     /**
-     * Applies an icon to a tag. The call is awaited and its rejection reported: a
-     * silently dropped promise here leaves the pin with its default white look.
+     * Applies an icon to a tag, unless that icon is already the one applied. The call is
+     * awaited and its rejection reported: a silently dropped promise here leaves the pin
+     * with its default white look.
      */
     private editTagIcon;
     /** Navigates the camera to the most recently created tag. */

package/lib/services/models/base-object.service.d.ts

@@ -1,11 +1,13 @@
 import { Equipment, Feature, POI, Ticket } from "../../types.service";
 import { NavigationService } from "./navigation.service";
 import { PoiService } from "./poi.service";
+import { VisitService } from "./visit.service";
 import * as i0 from "@angular/core";
 export declare class BaseObjectService {
     protected poiService: PoiService;
     private navigationService;
-    constructor(poiService: PoiService, navigationService: NavigationService);
+    private visitService;
+    constructor(poiService: PoiService, navigationService: NavigationService, visitService: VisitService);
     getModel3dAndSweep(object: Feature | Ticket | Equipment): Promise<{
         model3D: string;
         sweep: string;
@@ -14,6 +16,14 @@ export declare class BaseObjectService {
             y: number;
         };
     } | void>;
+    /**
+     * The space's 3D visit, or null when it has none.
+     *
+     * Takes the first one the database returns. That is not the space's chosen default - the
+     * default ordering lives in SpaceService, which cannot be injected here. The POI does not record
+     * which capture it was placed in, so with several 3D models this is a guess either way.
+     */
+    private getThreeJsVisitForSpace;
     updateIconForAllObjects(objects: Ticket[] | Feature[] | Equipment[], tagIcon: string): Promise<POI[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseObjectService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseObjectService>;

package/lib/services/models/equipment.service.d.ts

@@ -10,6 +10,7 @@ import { BaseObjectService } from './base-object.service';
 import { NavigationService } from './navigation.service';
 import { OperationService } from './operation.service';
 import { PoiService } from './poi.service';
+import { VisitService } from './visit.service';
 import { TicketsService } from './ticket.service';
 import { ZoneChangeService } from "../zoneChange.service";
 import * as i0 from "@angular/core";
@@ -49,7 +50,7 @@ export declare class EquipmentService extends BaseObjectService {
     awsKinesisAnalytics: any;
     isMuseumUser: boolean;
     private destroy$;
-    constructor(apiInjected: any, awsKinesisAnalyticsInjected: any, poiService: PoiService, navigationService: NavigationService, operationService: OperationService, ticketsService: TicketsService, navigatorService: NavigatorService, filterService: FilterService, userService: BaseUserService, viewerService: ViewerService, modalService: NgbModal, zoneChangeService: ZoneChangeService);
+    constructor(apiInjected: any, awsKinesisAnalyticsInjected: any, poiService: PoiService, navigationService: NavigationService, visitService: VisitService, operationService: OperationService, ticketsService: TicketsService, navigatorService: NavigatorService, filterService: FilterService, userService: BaseUserService, viewerService: ViewerService, modalService: NgbModal, zoneChangeService: ZoneChangeService);
     readEquipment(id: string): Promise<Equipment>;
     createEquipment(equip: Equipment, imageFile: File, documentFile: File): Promise<Equipment | void>;
     getSignedUrlsForEquipment(equip: Equipment): Promise<Equipment>;

package/lib/services/models/feature.service.d.ts

@@ -9,6 +9,7 @@ import { CommentService } from "./comment.service";
 import { HashtagService } from "./hashtag.service";
 import { NavigationService } from "./navigation.service";
 import { PoiService } from "./poi.service";
+import { VisitService } from "./visit.service";
 import { ZoneChangeService } from "../zoneChange.service";
 import * as i0 from "@angular/core";
 export declare class FeatureService extends BaseObjectService {
@@ -40,7 +41,7 @@ export declare class FeatureService extends BaseObjectService {
     currentHashtags: Hashtag[];
     createObservable: Subject<Feature>;
     deleteObservable: Subject<Feature>;
-    constructor(apiInjected: any, navigatorService: NavigatorService, filterService: FilterService, poiService: PoiService, commentService: CommentService, userService: BaseUserService, navigationService: NavigationService, hashtagService: HashtagService, zoneChangeService: ZoneChangeService);
+    constructor(apiInjected: any, navigatorService: NavigatorService, filterService: FilterService, poiService: PoiService, commentService: CommentService, userService: BaseUserService, navigationService: NavigationService, visitService: VisitService, hashtagService: HashtagService, zoneChangeService: ZoneChangeService);
     createFeature(feature: Feature): Promise<Feature>;
     deleteFeature(feature: Feature): Promise<Feature>;
     updateFeature(feature: any): Promise<Feature>;

package/lib/services/models/poi.service.d.ts

@@ -33,6 +33,7 @@ export declare class PoiService {
     * splitting keeps each request well within safe limits regardless of space size.
     */
     getPoisByMatterportSweeps(sweeps: string[]): Promise<POI[]>;
+    private scanPoisForSweepChunk;
     unsubscribe(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PoiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PoiService>;

package/lib/services/models/space.service.d.ts

@@ -47,6 +47,13 @@ export declare class SpaceService {
      * viewer offers them as a list, so the caller needs all of them rather than just the first.
      */
     getAllowedVisitsForSpace(spaceID: string): Promise<Visit[]>;
+    /**
+     * Sets which capture a visitor opens by default for this space.
+     *
+     * Pass null to clear it. Writing a single field on the space is what keeps the answer unique:
+     * there is nothing to clear elsewhere, and no way for two captures to both claim it.
+     */
+    setDefaultCapture(spaceID: string, captureID: string | null): Promise<Space>;
     getAllowedModel3DForSpace(spaceID: string): Promise<string>;
     softDeleteSpace(spaceID: string): Promise<void>;
     /**

package/lib/services/models/ticket.service.d.ts

@@ -10,6 +10,7 @@ import { BaseObjectService } from './base-object.service';
 import { NavigationService } from './navigation.service';
 import { OperationService } from './operation.service';
 import { PoiService } from './poi.service';
+import { VisitService } from './visit.service';
 import { EventService } from './event.service';
 import { InterventionService } from '../intervention.service';
 import { AffectationService } from './affectation.service';
@@ -38,6 +39,8 @@ export declare class TicketsService extends BaseObjectService {
     }>;
     currentSpaceID: string;
     zoneIDFilter: string;
+    /** Set while a viewer without zone navigation (Three.js) is showing a space. */
+    private spaceSubscription;
     dateFilter: Date[];
     ticketTypeFilter: TicketType[];
     reportingIcon: import("@iconify/types").IconifyIcon;
@@ -55,7 +58,7 @@ export declare class TicketsService extends BaseObjectService {
     floorsPerSpace: Zone[];
     selectedFloor: Zone;
     private destroy$;
-    constructor(awsKinesisAnalyticsInjected: any, apiInjected: any, operationService: OperationService, eventService: EventService, affectationService: AffectationService, poiService: PoiService, userService: BaseUserService, navigatorService: NavigatorService, filterService: FilterService, interventionService: InterventionService, navigationService: NavigationService, viewerService: ViewerService, zoneChangeService: ZoneChangeService, modalService: NgbModal);
+    constructor(awsKinesisAnalyticsInjected: any, apiInjected: any, operationService: OperationService, eventService: EventService, affectationService: AffectationService, poiService: PoiService, userService: BaseUserService, navigatorService: NavigatorService, filterService: FilterService, interventionService: InterventionService, navigationService: NavigationService, visitService: VisitService, viewerService: ViewerService, zoneChangeService: ZoneChangeService, modalService: NgbModal);
     initTickets(): Promise<void>;
     adaptTicket(ticket: Ticket): Promise<Ticket>;
     getPriorityColor(ticket: Ticket): string;

package/lib/services/threejs.service.d.ts

@@ -20,6 +20,8 @@ export interface ThreeJsTag {
     };
     /** Drives both the click route and type filtering, so it travels with the tag. */
     poiType?: PoiType | null;
+    /** Shown on hover. A marker with no identity is just a dot on a wall. */
+    label?: string | null;
     /** Icon drawn on the tag. Falls back to a plain disc when absent or it fails to load. */
     iconUrl?: string | null;
     /** Tint for the fallback disc, as a CSS colour. */
@@ -49,6 +51,8 @@ export interface ThreeJsTagPlacement {
         y: number;
         z: number;
     };
+    /** What the placement was armed for, so the caller knows which creation form to open. */
+    poiType?: PoiType | null;
 }
 /** One tag seen in both spaces: where it is stored, and where it really sits on the model. */
 export interface ThreeJsAlignmentPair {
@@ -114,6 +118,11 @@ export declare class ThreeJsService {
     objectClicked$: Subject<string>;
     /** Emits when the user clicks a tag, mirroring Matterport's tag click. */
     tagClicked$: Subject<ThreeJsTagClick>;
+    /** Emits a tag's label while the pointer is over it, and null when it leaves. */
+    tagHovered$: Subject<{
+        label: string;
+        event: MouseEvent;
+    }>;
     private tagGroup;
     private tagSprites;
     private canvasResizeObserver?;
@@ -122,10 +131,30 @@ export declare class ThreeJsService {
     private modelRoot?;
     /** True while the next click on the model places a tag instead of orbiting. */
     private placingTag;
+    /** What the armed placement is for, echoed back when the spot is picked. */
+    private placementPoiType;
     /** Position and normal of the last placed tag, in model space, awaiting commit to a POI. */
     private pendingTagPlacement;
+    /** Pointer position waiting for a preview pick, coalesced to one per frame. */
+    private pendingPreviewEvent;
+    /**
+     * Layer carrying the model alone, so the depth pick can render it without the tags.
+     *
+     * Layers are tested per object at render time and children are traversed regardless of whether
+     * their parent passed, so marking the model's own meshes is enough - no re-parenting.
+     */
+    private static readonly PICK_LAYER;
+    /** Cache Storage bucket holding downloaded models, and how many to keep. */
+    private static readonly MODEL_CACHE;
+    private static readonly MODEL_CACHE_SIZE;
+    private pickTarget?;
+    private pickCamera?;
+    private pickDepthMaterial?;
+    private readonly pickPixel;
     /** Emits once a tag is dropped on the model, so the UI can confirm and persist it. */
     tagPlaced$: Subject<ThreeJsTagPlacement>;
+    /** Emits when the calibration walkthrough is abandoned, so the panel driving it can close. */
+    alignmentCancelled$: Subject<void>;
     /** Translucent marker shown under the cursor while placing. */
     private placementPreview?;
     private aligning;
@@ -191,7 +220,7 @@ export declare class ThreeJsService {
         x: number;
         y: number;
         z: number;
-    }): void;
+    }, cacheKey?: string): void;
     /**
      * Stops the model download in progress, if any.
      *
@@ -225,6 +254,25 @@ export declare class ThreeJsService {
      * stream reports it as it happens rather than in one jump at the end.
      */
     private fetchWithProgress;
+    /**
+     * The model store, or null where the browser will not give us one.
+     *
+     * Cache Storage needs a secure context, so it is absent over plain http and in some embedded
+     * webviews. Every caller treats that as a miss - caching is an optimisation, never a requirement.
+     */
+    private openModelCache;
+    /**
+     * A cached copy of this model, if one was stored.
+     *
+     * Keyed by the S3 key rather than the URL it is fetched from: that URL is signed, so it carries a
+     * fresh signature and expiry every time and would never match twice. The browser's own HTTP cache
+     * misses for the same reason, which is why this exists at all.
+     */
+    private readModelFromCache;
+    /** Stores a model for next time, evicting the oldest once a few are held. */
+    private writeModelToCache;
+    /** Cache Storage keys on a URL, so the S3 key is expressed as one. It is never requested. */
+    private modelCacheUrl;
     /**
      * Fits the camera's clipping planes to how big the model actually is.
      *
@@ -326,6 +374,16 @@ export declare class ThreeJsService {
     startTagAlignment(): void;
     cancelTagAlignment(): void;
     isAligningTags(): boolean;
+    /**
+     * Whether the pointer should be showing the placement ghost.
+     *
+     * True while placing a tag, and while calibrating once a tag has been picked - that second click
+     * is the same question ("where on the model?") and deserves the same aiming aid. Not true for the
+     * first half of a pair, which is a click on a tag, not on the model.
+     */
+    private isPreviewingPlacement;
+    /** Whether a tag is currently registered for this element. */
+    hasTag(elementId: string): boolean;
     /**
      * Solves and applies the alignment collected so far, returning it so the caller can persist it.
      *
@@ -336,7 +394,7 @@ export declare class ThreeJsService {
     /** Handles a click while the alignment walkthrough is running. */
     private handleAlignmentClick;
     /** Arms tag placement: the next click on the model drops a tag instead of being ignored. */
-    startTagPlacement(): void;
+    startTagPlacement(poiType?: PoiType | null): void;
     /** Leaves placement mode without placing anything. */
     cancelTagPlacement(): void;
     /**
@@ -346,6 +404,21 @@ export declare class ThreeJsService {
      * sprite that gets removed the moment the real tag takes its place.
      */
     private updatePlacementPreview;
+    /**
+     * The point under the cursor, read from the depth buffer instead of raycast, in tag space.
+     *
+     * A raycast walks every triangle of the mesh it hits: on a captured model that is millions of
+     * them, tens of milliseconds, every time the pointer moves. Coalescing to one per frame did not
+     * help, because the cost is the pick itself - it simply became one slow frame instead of several.
+     *
+     * Rendering the model's depth into a single pixel under the cursor answers the same question on
+     * the GPU in constant time, whatever the model's size. The camera's view offset is what narrows
+     * the whole image down to that one pixel, so the value read back is the depth the cursor is over.
+     *
+     * Used for the ghost only. The click that actually places a tag still raycasts: it is one pick,
+     * its cost does not matter, and it yields the surface normal, which depth alone cannot give.
+     */
+    private pickPointOnGpu;
     private removePlacementPreview;
     /** Shows or hides one tag, leaving it registered so it can be brought back without reloading. */
     setTagVisibility(elementId: string, visible: boolean): void;
@@ -370,12 +443,30 @@ export declare class ThreeJsService {
     /** The spot picked by the last placement, for whoever commits it to a POI. */
     getPendingTagPlacement(): ThreeJsTagPlacement | null;
     /**
-     * Turns a click into a point on the model, in model space.
+     * Raycasts a click against the model's geometry and returns the hit, in world space.
      *
-     * Returns null when the click missed the geometry, which is a normal outcome - the user clicked
-     * the sky - and leaves placement mode armed so they can simply try again.
+     * Returns null when the click missed, which is a normal outcome - the user clicked the sky - and
+     * leaves whatever mode is armed still armed, so they can simply try again.
+     */
+    private raycastModel;
+    /**
+     * Turns a click into a point on the model, in the frame tag coordinates are persisted in.
+     *
+     * That frame is the tag group's, not the model's. A stored coordinate is read back as a sprite
+     * position inside that group, so a coordinate captured in any other frame comes back displaced by
+     * exactly however far the alignment moves the group. The two frames agree only while the
+     * alignment is identity, which is why this stayed invisible until a model was calibrated.
      */
     private pickPlacementOnModel;
+    /**
+     * Where the user says a tag really belongs, in the space the solved alignment maps onto.
+     *
+     * setTagAlignment writes the solution to the tag group's own transform, which is expressed
+     * relative to its parent - so the target has to be in the parent's frame. Measuring it in the
+     * group's own frame instead would fold the current alignment into the answer, making each
+     * calibration depend on the one before it.
+     */
+    private pickAlignmentTarget;
     /**
      * Sets the transform mapping captured tag coordinates onto this model's space.
      *
@@ -416,6 +507,13 @@ export declare class ThreeJsService {
     updateObjsToScene(objsAdded: ObjAdded[]): void;
     private onMouseMove;
     private onMouseClick;
+    /**
+     * Escape cancels whatever the pointer is currently committed to.
+     *
+     * Emits through the same subjects the explicit Cancel buttons use, so the UI driving them follows
+     * along instead of being left showing a mode that is no longer armed.
+     */
+    private onKeyDown;
     private animate;
     destroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ThreeJsService, never>;