@iwsdk/core 0.5.3 → 1.0.0-rc.1

package/dist/scene-understanding/scene-understanding-system.js

@@ -73,8 +73,20 @@ class SceneUnderstandingSystem extends createSystem({
         super(...arguments);
         /** Tracks whether an anchor creation request is in progress to prevent duplicate requests */
         this.anchorRequested = false;
+        /** Render-clock deadline before another native anchor request may start. */
+        this.nextAnchorRequestTime = 0;
+        /** Index of the delay assigned to the next failed native anchor request. */
+        this.anchorRetryDelayIndex = 0;
+        /** Latest elapsed render-clock time, in seconds. */
+        this.anchorRetryClockTime = 0;
+        /** Invalidates asynchronous anchor work when the active XR session changes. */
+        this.anchorRequestGeneration = 0;
+        /** Prevents duplicate native-anchor disposal across async teardown paths. */
+        this.deletedAnchors = new WeakSet();
         this.currentPlanes = new Map();
         this.currentMeshes = new Map();
+        this.planeGeometryStates = new Map();
+        this.meshGeometryStates = new Map();
         /** Group that holds all anchored objects, positioned to match the XRAnchor's world pose */
         this.anchoredGroup = new Group();
         this.matrixBuffer = new Matrix4();
@@ -93,7 +105,7 @@ class SceneUnderstandingSystem extends createSystem({
             wireframe: true,
             opacity: 0.3,
         });
-        this.xrManager.addEventListener('sessionstart', async () => {
+        const onSessionStart = async () => {
             this.updateEnabledFeatures(this.xrManager.getSession());
             // Attempt to restore a persistent anchor from previous sessions
             // This allows anchored objects to maintain their world position across sessions
@@ -110,35 +122,24 @@ class SceneUnderstandingSystem extends createSystem({
             // ) {
             // 	await this.xrManager.getSession()?.initiateRoomCapture();
             // }
-        });
-        this.xrManager.addEventListener('sessionend', () => {
+        };
+        const onSessionEnd = () => {
             // Clean up all plane and mesh entities to prevent stale XRSpace references
             // XRSpace objects (like planeSpace, meshSpace, anchorSpace) are tied to a specific
             // XRSession and become invalid when the session ends. Using them with a new session's
             // XRFrame will cause "XRSpace and XRFrame sessions do not match" errors.
-            this.queries.planeEntities.entities.forEach((entity) => {
-                this.disposeEntityGeometry(entity);
-                entity.destroy();
-            });
-            this.queries.meshEntities.entities.forEach((entity) => {
-                this.disposeEntityGeometry(entity);
-                entity.destroy();
-            });
+            this.disposeDetectedEntities();
             // Clear session-specific state to prevent stale references
             // Note: The persistent anchor UUID in localStorage is preserved for the next session
-            this.xrAnchor = undefined;
-            this.anchorRequested = false;
-            this.planeFeatureEnabled = undefined;
-            this.meshFeatureEnabled = undefined;
-            this.anchorFeatureEnabled = undefined;
-            this.currentPlanes.clear();
-            this.currentMeshes.clear();
-        });
-        this.world.createTransformEntity(this.anchoredGroup, {
+            this.resetSessionState();
+        };
+        this.xrManager.addEventListener('sessionstart', onSessionStart);
+        this.xrManager.addEventListener('sessionend', onSessionEnd);
+        this.anchoredGroupEntity = this.world.createTransformEntity(this.anchoredGroup, {
             parent: this.world.sceneEntity,
             persistent: true,
         });
-        this.cleanupFuncs.push(this.config.showWireFrame.subscribe((value) => {
+        this.cleanupFuncs.push(() => this.xrManager.removeEventListener('sessionstart', onSessionStart), () => this.xrManager.removeEventListener('sessionend', onSessionEnd), this.config.showWireFrame.subscribe((value) => {
             this.queries.planeEntities.entities.forEach((planeEntity) => {
                 const planeObject = planeEntity.object3D;
                 if (planeObject instanceof Mesh) {
@@ -151,10 +152,31 @@ class SceneUnderstandingSystem extends createSystem({
                     meshObject.visible = value;
                 }
             });
-        }));
+        }), () => {
+            var _a;
+            this.disposeDetectedEntities();
+            this.resetSessionState();
+            for (const entity of [...this.queries.anchoredEntities.entities]) {
+                const object = entity.object3D;
+                if ((object === null || object === void 0 ? void 0 : object.parent) === this.anchoredGroup) {
+                    this.scene.attach(object);
+                }
+                if (entity.active) {
+                    entity.setValue(XRAnchor, 'attached', false);
+                }
+            }
+            this.anchoredGroup.removeFromParent();
+            if ((_a = this.anchoredGroupEntity) === null || _a === void 0 ? void 0 : _a.active) {
+                this.anchoredGroupEntity.destroy();
+            }
+            this.anchoredGroupEntity = undefined;
+            this.planeMaterial.dispose();
+            this.meshMaterial.dispose();
+        });
     }
-    update(_delta, _time) {
+    update(_delta, time) {
         var _a;
+        this.anchorRetryClockTime = time;
         const frame = this.xrFrame;
         const planes = frame === null || frame === void 0 ? void 0 : frame.detectedPlanes;
         const meshes = frame === null || frame === void 0 ? void 0 : frame.detectedMeshes;
@@ -167,8 +189,8 @@ class SceneUnderstandingSystem extends createSystem({
         }
         if (this.anchorFeatureEnabled &&
             this.xrAnchor === undefined &&
-            !this.anchorRequested) {
-            console.log('[SceneUnderstandingSystem] Anchor needed but not present, triggering creation');
+            !this.anchorRequested &&
+            time >= this.nextAnchorRequestTime) {
             this.createAnchor(referenceSpace);
         }
         if (this.xrAnchor && referenceSpace) {
@@ -192,6 +214,66 @@ class SceneUnderstandingSystem extends createSystem({
             object3D.geometry.dispose();
         }
     }
+    disposeDetectedEntities() {
+        const entities = new Set([
+            ...this.queries.planeEntities.entities,
+            ...this.queries.meshEntities.entities,
+        ]);
+        for (const entity of entities) {
+            this.disposeEntityGeometry(entity);
+            if (entity.active) {
+                entity.destroy();
+            }
+        }
+        this.currentPlanes.clear();
+        this.currentMeshes.clear();
+        this.planeGeometryStates.clear();
+        this.meshGeometryStates.clear();
+    }
+    resetSessionState() {
+        this.anchorRequestGeneration++;
+        this.anchorRequested = false;
+        this.resetAnchorRetryState();
+        this.clearActiveAnchor();
+        this.planeFeatureEnabled = undefined;
+        this.meshFeatureEnabled = undefined;
+        this.anchorFeatureEnabled = undefined;
+    }
+    isAnchorRequestCurrent(session, requestGeneration) {
+        return (requestGeneration === this.anchorRequestGeneration &&
+            session === this.xrManager.getSession());
+    }
+    deleteAnchor(anchor) {
+        if (!anchor || this.deletedAnchors.has(anchor)) {
+            return;
+        }
+        this.deletedAnchors.add(anchor);
+        try {
+            anchor.delete();
+        }
+        catch (_error) {
+            // The session may already have ended, but the anchor must still be
+            // forgotten locally and must never be installed into a later session.
+        }
+    }
+    clearActiveAnchor() {
+        const anchor = this.xrAnchor;
+        this.xrAnchor = undefined;
+        this.deleteAnchor(anchor);
+    }
+    resetAnchorRetryState() {
+        this.nextAnchorRequestTime = 0;
+        this.anchorRetryDelayIndex = 0;
+    }
+    increaseAnchorRetryDelay(session, requestGeneration, requestDelayIndex) {
+        if (!this.isAnchorRequestCurrent(session, requestGeneration)) {
+            return;
+        }
+        this.nextAnchorRequestTime =
+            this.anchorRetryClockTime +
+                SceneUnderstandingSystem.ANCHOR_RETRY_DELAYS_SECONDS[requestDelayIndex];
+        this.anchorRetryDelayIndex = Math.min(requestDelayIndex + 1, SceneUnderstandingSystem.ANCHOR_RETRY_DELAYS_SECONDS.length - 1);
+    }
     updatePlanes(planes, referenceSpace) {
         this.currentPlanes.clear();
         this.queries.planeEntities.entities.forEach((planeEntity) => {
@@ -199,6 +281,7 @@ class SceneUnderstandingSystem extends createSystem({
                 this.currentPlanes.set(planeEntity.getValue(XRPlane, '_plane'), planeEntity);
             }
             else {
+                this.planeGeometryStates.delete(planeEntity.getValue(XRPlane, '_plane'));
                 this.disposeEntityGeometry(planeEntity);
                 planeEntity.destroy();
             }
@@ -215,24 +298,8 @@ class SceneUnderstandingSystem extends createSystem({
                     }
                     this.matrixBuffer.fromArray(pose.transform.matrix);
                     if (this.currentPlanes.has(plane) === false) {
-                        // Only build geometry for newly-seen planes. Doing it every frame
-                        // for every plane allocated a BoxGeometry that was then discarded
-                        // (without dispose) for already-tracked planes — a per-frame GPU
-                        // leak. Existing planes only need their transform refreshed below.
                         const polygon = plane.polygon;
-                        let minX = Number.MAX_SAFE_INTEGER;
-                        let maxX = Number.MIN_SAFE_INTEGER;
-                        let minZ = Number.MAX_SAFE_INTEGER;
-                        let maxZ = Number.MIN_SAFE_INTEGER;
-                        for (const point of polygon) {
-                            minX = Math.min(minX, point.x);
-                            maxX = Math.max(maxX, point.x);
-                            minZ = Math.min(minZ, point.z);
-                            maxZ = Math.max(maxZ, point.z);
-                        }
-                        const width = maxX - minX;
-                        const height = maxZ - minZ;
-                        const geometry = new BoxGeometry(width, 0.001, height);
+                        const geometry = this.createPlaneGeometry(polygon);
                         const mesh = new Mesh(geometry, this.planeMaterial);
                         mesh.visible = this.config.showWireFrame.value;
                         mesh.position.setFromMatrixPosition(this.matrixBuffer);
@@ -242,9 +309,31 @@ class SceneUnderstandingSystem extends createSystem({
                         planeEntity.addComponent(XRPlane, {
                             _plane: plane,
                         });
+                        this.planeGeometryStates.set(plane, {
+                            lastChangedTime: plane.lastChangedTime,
+                            polygon,
+                        });
                     }
                     else {
                         const planeObject = (_a = this.currentPlanes.get(plane)) === null || _a === void 0 ? void 0 : _a.object3D;
+                        const previousState = this.planeGeometryStates.get(plane);
+                        if (planeObject instanceof Mesh &&
+                            (previousState === undefined ||
+                                previousState.lastChangedTime !== plane.lastChangedTime)) {
+                            const polygon = plane.polygon;
+                            // Conforming runtimes replace changed topology arrays. Keep the
+                            // identity guard because some emulators advance the timestamp on
+                            // every frame even when their topology is unchanged.
+                            if ((previousState === null || previousState === void 0 ? void 0 : previousState.polygon) !== polygon) {
+                                const previousGeometry = planeObject.geometry;
+                                planeObject.geometry = this.createPlaneGeometry(polygon);
+                                previousGeometry.dispose();
+                            }
+                            this.planeGeometryStates.set(plane, {
+                                lastChangedTime: plane.lastChangedTime,
+                                polygon,
+                            });
+                        }
                         planeObject === null || planeObject === void 0 ? void 0 : planeObject.position.setFromMatrixPosition(this.matrixBuffer);
                         planeObject === null || planeObject === void 0 ? void 0 : planeObject.quaternion.setFromRotationMatrix(this.matrixBuffer);
                     }
@@ -259,13 +348,13 @@ class SceneUnderstandingSystem extends createSystem({
                 this.currentMeshes.set(meshEntity.getValue(XRMesh, '_mesh'), meshEntity);
             }
             else {
+                this.meshGeometryStates.delete(meshEntity.getValue(XRMesh, '_mesh'));
                 this.disposeEntityGeometry(meshEntity);
                 meshEntity.destroy();
             }
         });
         if (meshes) {
             meshes.forEach((mesh) => {
-                var _a;
                 if (referenceSpace != null) {
                     const pose = this.xrManager
                         .getFrame()
@@ -275,43 +364,73 @@ class SceneUnderstandingSystem extends createSystem({
                     }
                     this.matrixBuffer.fromArray(pose.transform.matrix);
                     if (this.currentMeshes.has(mesh) === false) {
-                        // Only build geometry for newly-seen meshes. Building a
-                        // BufferGeometry every frame for every mesh and discarding it
-                        // (without dispose) for already-tracked meshes was a per-frame GPU
-                        // leak. Existing meshes only need their transform refreshed below.
-                        const geometry = new BufferGeometry();
-                        geometry.setAttribute('position', new BufferAttribute(mesh.vertices, 3));
-                        geometry.setIndex(new BufferAttribute(mesh.indices, 1));
+                        const vertices = mesh.vertices;
+                        const indices = mesh.indices;
+                        const metadata = this.tryGetMeshMetadata(vertices, mesh.semanticLabel);
+                        if (metadata === undefined) {
+                            return;
+                        }
+                        const geometry = this.createMeshGeometry(vertices, indices);
                         const threeMesh = new Mesh(geometry, this.meshMaterial);
                         threeMesh.visible = this.config.showWireFrame.value;
                         this.scene.add(threeMesh);
                         const meshEntity = this.world.createTransformEntity(threeMesh);
                         threeMesh.position.setFromMatrixPosition(this.matrixBuffer);
                         threeMesh.quaternion.setFromRotationMatrix(this.matrixBuffer);
-                        if (mesh.semanticLabel === 'global mesh') {
-                            meshEntity.addComponent(XRMesh, {
-                                _mesh: mesh,
-                                isBounded3D: false,
-                            });
-                        }
-                        else {
-                            const { minEntry, maxEntry } = findExtremeVertices(mesh.vertices);
-                            meshEntity.addComponent(XRMesh, {
-                                _mesh: mesh,
-                                isBounded3D: true,
-                                semanticLabel: mesh.semanticLabel,
-                                min: [minEntry.x, minEntry.y, minEntry.z],
-                                max: [maxEntry.x, maxEntry.y, maxEntry.z],
-                                dimensions: [
-                                    maxEntry.x - minEntry.x,
-                                    maxEntry.y - minEntry.y,
-                                    maxEntry.z - minEntry.z,
-                                ],
-                            });
-                        }
+                        meshEntity.addComponent(XRMesh, {
+                            _mesh: mesh,
+                            ...metadata,
+                        });
+                        this.meshGeometryStates.set(mesh, {
+                            indices,
+                            lastChangedTime: mesh.lastChangedTime,
+                            semanticLabel: mesh.semanticLabel,
+                            vertices,
+                        });
                     }
                     else {
-                        const meshObject = (_a = this.currentMeshes.get(mesh)) === null || _a === void 0 ? void 0 : _a.object3D;
+                        const meshEntity = this.currentMeshes.get(mesh);
+                        const meshObject = meshEntity === null || meshEntity === void 0 ? void 0 : meshEntity.object3D;
+                        const previousState = this.meshGeometryStates.get(mesh);
+                        if (meshEntity !== undefined &&
+                            meshObject instanceof Mesh &&
+                            (previousState === undefined ||
+                                previousState.lastChangedTime !== mesh.lastChangedTime)) {
+                            const vertices = mesh.vertices;
+                            const indices = mesh.indices;
+                            const semanticLabel = mesh.semanticLabel;
+                            // See the plane path above: timestamp changes alone are noisy in
+                            // some emulators, while conforming topology updates replace the
+                            // vertex or index array.
+                            const topologyChanged = (previousState === null || previousState === void 0 ? void 0 : previousState.vertices) !== vertices ||
+                                (previousState === null || previousState === void 0 ? void 0 : previousState.indices) !== indices;
+                            const metadataChanged = topologyChanged ||
+                                (previousState === null || previousState === void 0 ? void 0 : previousState.semanticLabel) !== semanticLabel;
+                            const metadata = metadataChanged
+                                ? this.tryGetMeshMetadata(vertices, semanticLabel)
+                                : undefined;
+                            if (metadataChanged && metadata === undefined) {
+                                // Keep the last known-good geometry and component metadata.
+                                // A later valid topology update can still replace them.
+                                meshObject.position.setFromMatrixPosition(this.matrixBuffer);
+                                meshObject.quaternion.setFromRotationMatrix(this.matrixBuffer);
+                                return;
+                            }
+                            if (topologyChanged) {
+                                const previousGeometry = meshObject.geometry;
+                                meshObject.geometry = this.createMeshGeometry(vertices, indices);
+                                previousGeometry.dispose();
+                            }
+                            if (metadata !== undefined) {
+                                this.updateMeshMetadata(meshEntity, metadata);
+                            }
+                            this.meshGeometryStates.set(mesh, {
+                                indices,
+                                lastChangedTime: mesh.lastChangedTime,
+                                semanticLabel,
+                                vertices,
+                            });
+                        }
                         meshObject === null || meshObject === void 0 ? void 0 : meshObject.position.setFromMatrixPosition(this.matrixBuffer);
                         meshObject === null || meshObject === void 0 ? void 0 : meshObject.quaternion.setFromRotationMatrix(this.matrixBuffer);
                     }
@@ -319,6 +438,68 @@ class SceneUnderstandingSystem extends createSystem({
             });
         }
     }
+    createPlaneGeometry(polygon) {
+        let minX = Number.MAX_SAFE_INTEGER;
+        let maxX = Number.MIN_SAFE_INTEGER;
+        let minZ = Number.MAX_SAFE_INTEGER;
+        let maxZ = Number.MIN_SAFE_INTEGER;
+        for (const point of polygon) {
+            minX = Math.min(minX, point.x);
+            maxX = Math.max(maxX, point.x);
+            minZ = Math.min(minZ, point.z);
+            maxZ = Math.max(maxZ, point.z);
+        }
+        return new BoxGeometry(maxX - minX, 0.001, maxZ - minZ);
+    }
+    createMeshGeometry(vertices, indices) {
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new BufferAttribute(vertices, 3));
+        geometry.setIndex(new BufferAttribute(indices, 1));
+        return geometry;
+    }
+    getMeshMetadata(vertices, semanticLabel) {
+        if (semanticLabel === 'global mesh') {
+            return {
+                dimensions: [0, 0, 0],
+                isBounded3D: false,
+                max: [0, 0, 0],
+                min: [0, 0, 0],
+                semanticLabel: '',
+            };
+        }
+        const { minEntry, maxEntry } = findAxisAlignedBounds(vertices);
+        return {
+            dimensions: [
+                maxEntry.x - minEntry.x,
+                maxEntry.y - minEntry.y,
+                maxEntry.z - minEntry.z,
+            ],
+            isBounded3D: true,
+            max: [maxEntry.x, maxEntry.y, maxEntry.z],
+            min: [minEntry.x, minEntry.y, minEntry.z],
+            semanticLabel: semanticLabel !== null && semanticLabel !== void 0 ? semanticLabel : '',
+        };
+    }
+    tryGetMeshMetadata(vertices, semanticLabel) {
+        try {
+            return this.getMeshMetadata(vertices, semanticLabel);
+        }
+        catch (error) {
+            console.warn('[SceneUnderstandingSystem] Skipping mesh with invalid vertex data.', error);
+            return undefined;
+        }
+    }
+    updateMeshMetadata(entity, metadata) {
+        entity.getVectorView(XRMesh, 'min').set(metadata.min);
+        entity.getVectorView(XRMesh, 'max').set(metadata.max);
+        entity.getVectorView(XRMesh, 'dimensions').set(metadata.dimensions);
+        if (entity.getValue(XRMesh, 'semanticLabel') !== metadata.semanticLabel) {
+            entity.setValue(XRMesh, 'semanticLabel', metadata.semanticLabel);
+        }
+        if (entity.getValue(XRMesh, 'isBounded3D') !== metadata.isBounded3D) {
+            entity.setValue(XRMesh, 'isBounded3D', metadata.isBounded3D);
+        }
+    }
     updateEnabledFeatures(xrSession) {
         if (!xrSession) {
             console.log('Warning: xrSession is null when trying to query enabled features. Scene understanding  features are disabled.');
@@ -350,33 +531,62 @@ class SceneUnderstandingSystem extends createSystem({
      * anchor will be created in the update loop.
      */
     async tryRestorePersistentAnchor() {
+        let requestGeneration;
+        let session = null;
         try {
             // Load the saved anchor UUID from localStorage
             const savedUuid = localStorage.getItem(SceneUnderstandingSystem.ANCHOR_UUID_STORAGE_KEY);
             if (!savedUuid) {
                 return;
             }
-            const session = this.xrManager.getSession();
+            session = this.xrManager.getSession();
             if (!session) {
                 return;
             }
-            // Attempt to restore the anchor using the saved UUID
-            this.anchorRequested = true;
             if (!session.restorePersistentAnchor) {
                 console.warn('XRSession.restorePersistentAnchor not supported');
-                this.anchorRequested = false;
                 return;
             }
-            this.xrAnchor = await session.restorePersistentAnchor(savedUuid);
-            if (!this.xrAnchor) {
-                // Restoration returned null, will create new anchor
-                this.anchorRequested = false;
+            // Each async request owns a generation. Session end, system teardown, or
+            // a subsequent restore invalidates it so a late result cannot install an
+            // XRAnchor whose XRSpace belongs to an obsolete XRSession.
+            requestGeneration = ++this.anchorRequestGeneration;
+            this.anchorRequested = true;
+            const restoredAnchor = (await session.restorePersistentAnchor(savedUuid));
+            if (!this.isAnchorRequestCurrent(session, requestGeneration)) {
+                this.deleteAnchor(restoredAnchor);
+                return;
+            }
+            if (!restoredAnchor) {
+                this.clearActiveAnchor();
+                return;
+            }
+            if (this.xrAnchor !== restoredAnchor) {
+                this.clearActiveAnchor();
+                this.xrAnchor = restoredAnchor;
             }
+            this.resetAnchorRetryState();
         }
         catch (_error) {
-            // Restoration failed - clear the invalid UUID and allow new anchor creation
-            localStorage.removeItem(SceneUnderstandingSystem.ANCHOR_UUID_STORAGE_KEY);
-            this.anchorRequested = false;
+            // Only the current session's failure proves that its saved UUID is
+            // invalid. A superseded session may reject merely because it ended.
+            if (requestGeneration === undefined ||
+                (session !== null &&
+                    this.isAnchorRequestCurrent(session, requestGeneration))) {
+                try {
+                    localStorage.removeItem(SceneUnderstandingSystem.ANCHOR_UUID_STORAGE_KEY);
+                }
+                catch (_storageError) {
+                    // Storage access can be unavailable in privacy-restricted contexts.
+                }
+            }
+        }
+        finally {
+            // A stale request must not clear the in-flight marker owned by the next
+            // session's restore.
+            if (requestGeneration === this.anchorRequestGeneration) {
+                this.anchorRequested = false;
+            }
         }
     }
     /**
@@ -388,28 +598,71 @@ class SceneUnderstandingSystem extends createSystem({
      * will only last for the current session.
      */
     async createAnchor(referenceSpace) {
-        const frame = this.xrManager.getFrame();
-        if (!frame.createAnchor) {
-            throw 'XRFrame.createAnchor is undefined';
-        }
-        if (!referenceSpace) {
-            throw 'renderer.xr.getReferenceSpace() returned null';
-        }
-        this.anchorRequested = true;
-        this.xrAnchor = await frame.createAnchor(new XRRigidTransform(), referenceSpace);
-        if (!this.xrAnchor) {
-            this.anchorRequested = false;
-            throw 'XRAnchor creation failed';
-        }
-        // Request a persistent handle for the anchor so it can be restored in future sessions
+        let requestGeneration;
+        let session = null;
+        let createdAnchor;
+        let requestDelayIndex;
         try {
-            if (this.xrAnchor.requestPersistentHandle) {
-                const uuid = await this.xrAnchor.requestPersistentHandle();
+            session = this.xrManager.getSession();
+            const frame = this.xrManager.getFrame();
+            if (!session || !(frame === null || frame === void 0 ? void 0 : frame.createAnchor) || !referenceSpace) {
+                return;
+            }
+            requestGeneration = ++this.anchorRequestGeneration;
+            this.anchorRequested = true;
+            requestDelayIndex = this.anchorRetryDelayIndex;
+            console.log('[SceneUnderstandingSystem] Anchor needed but not present, triggering creation');
+            createdAnchor = (await frame.createAnchor(new XRRigidTransform(), referenceSpace));
+            if (!createdAnchor) {
+                this.increaseAnchorRetryDelay(session, requestGeneration, requestDelayIndex);
+                return;
+            }
+            if (!this.isAnchorRequestCurrent(session, requestGeneration)) {
+                this.deleteAnchor(createdAnchor);
+                return;
+            }
+            if (this.xrAnchor !== createdAnchor) {
+                this.clearActiveAnchor();
+                this.xrAnchor = createdAnchor;
+            }
+            this.resetAnchorRetryState();
+            if (createdAnchor.requestPersistentHandle) {
+                const uuid = await createdAnchor.requestPersistentHandle();
+                if (!this.isAnchorRequestCurrent(session, requestGeneration) ||
+                    this.xrAnchor !== createdAnchor) {
+                    if (this.xrAnchor === createdAnchor) {
+                        this.xrAnchor = undefined;
+                    }
+                    this.deleteAnchor(createdAnchor);
+                    return;
+                }
                 localStorage.setItem(SceneUnderstandingSystem.ANCHOR_UUID_STORAGE_KEY, uuid);
             }
         }
         catch (_error) {
-            // Persistence not supported or failed - anchor will work for this session only
+            // Anchor creation and persistence are optional. A current created anchor
+            // remains usable when only persistence fails; a stale one is discarded.
+            if (!createdAnchor &&
+                requestGeneration !== undefined &&
+                requestDelayIndex !== undefined &&
+                session !== null) {
+                this.increaseAnchorRetryDelay(session, requestGeneration, requestDelayIndex);
+            }
+            if (createdAnchor &&
+                requestGeneration !== undefined &&
+                session !== null &&
+                (!this.isAnchorRequestCurrent(session, requestGeneration) ||
+                    this.xrAnchor !== createdAnchor)) {
+                if (this.xrAnchor === createdAnchor) {
+                    this.xrAnchor = undefined;
+                }
+                this.deleteAnchor(createdAnchor);
+            }
+        }
+        finally {
+            if (requestGeneration === this.anchorRequestGeneration) {
+                this.anchorRequested = false;
+            }
         }
     }
     updateAnchoredObject() {
@@ -422,15 +675,47 @@ class SceneUnderstandingSystem extends createSystem({
         });
     }
 }
+/** Delays between failed native anchor requests. */
+SceneUnderstandingSystem.ANCHOR_RETRY_DELAYS_SECONDS = [
+    0.25, 0.5, 1, 2, 5,
+];
 /** localStorage key for storing the persistent anchor UUID */
 SceneUnderstandingSystem.ANCHOR_UUID_STORAGE_KEY = 'iwsdk_scene_anchor_uuid';
 /**
- * From a flat `[x,y,z, x,y,z, ...]` vertex buffer, return the vertices with the
- * smallest and largest coordinate sum (`x + y + z`).
+ * From a flat `[x,y,z, x,y,z, ...]` vertex buffer, return its axis-aligned
+ * minimum and maximum coordinates. The extrema can come from different source
+ * vertices; treating one smallest-sum and one largest-sum vertex as bounds
+ * under-reports skewed meshes.
+ */
+function findAxisAlignedBounds(arr) {
+    if (!arr || arr.length === 0 || arr.length % 3 !== 0) {
+        throw new Error('Array length must be a positive multiple of 3.');
+    }
+    let minX = arr[0];
+    let minY = arr[1];
+    let minZ = arr[2];
+    let maxX = minX;
+    let maxY = minY;
+    let maxZ = minZ;
+    for (let i = 3; i < arr.length; i += 3) {
+        minX = Math.min(minX, arr[i]);
+        minY = Math.min(minY, arr[i + 1]);
+        minZ = Math.min(minZ, arr[i + 2]);
+        maxX = Math.max(maxX, arr[i]);
+        maxY = Math.max(maxY, arr[i + 1]);
+        maxZ = Math.max(maxZ, arr[i + 2]);
+    }
+    return {
+        minEntry: { x: minX, y: minY, z: minZ },
+        maxEntry: { x: maxX, y: maxY, z: maxZ },
+    };
+}
+/**
+ * From a flat `[x,y,z, x,y,z, ...]` vertex buffer, return the source
+ * vertices with the smallest and largest coordinate sums.
  *
- * Equivalent to the previous `flatToVec3Array(...)` -> `findMinMaxEntries(...)`
- * pipeline, but it scans the typed array directly and allocates only the two
- * result objects instead of one object per vertex (thousands per mesh).
+ * @deprecated This legacy helper does not calculate an axis-aligned bounding
+ * box. Use {@link findAxisAlignedBounds} for bounds and dimensions.
  */
 function findExtremeVertices(arr) {
     if (!arr || arr.length === 0 || arr.length % 3 !== 0) {
@@ -457,5 +742,5 @@ function findExtremeVertices(arr) {
     };
 }
 
-export { SceneUnderstandingSystem, findExtremeVertices };
+export { SceneUnderstandingSystem, findAxisAlignedBounds, findExtremeVertices };
 //# sourceMappingURL=scene-understanding-system.js.map