@multisetai/vps 1.0.6 → 1.0.7-beta.1

package/dist/index.js

@@ -1,8 +1,10 @@
 import axios from 'axios';
-import * as THREE from 'three';
+import * as THREE3 from 'three';
 import { ARButton } from 'three/examples/jsm/webxr/ARButton.js';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 
-// src/lib/core/index.ts
+// src/lib/core/config.ts
 var DEFAULT_ENDPOINTS = {
   authUrl: "https://api.multiset.ai/v1/m2m/token",
   queryUrl: "https://api.multiset.ai/v1/vps/map/query-form",
@@ -14,6 +16,7 @@ var MultisetClient = class {
   constructor(config) {
     this.config = config;
     this.accessToken = null;
+    this.mapDetailsCache = {};
     this.config = config;
     this.endpoints = {
       ...DEFAULT_ENDPOINTS,
@@ -23,6 +26,28 @@ var MultisetClient = class {
   get token() {
     return this.accessToken;
   }
+  getConfig() {
+    return this.config;
+  }
+  async downloadFile(key) {
+    if (!this.accessToken || !key) {
+      return "";
+    }
+    try {
+      const response = await axios.get(
+        `${this.endpoints.fileDownloadUrl}?key=${encodeURIComponent(key)}`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        }
+      );
+      return response.status === 200 ? response.data.url : "";
+    } catch (error) {
+      this.handleError(error);
+      return "";
+    }
+  }
   async authorize() {
     var _a, _b, _c, _d, _e;
     try {
@@ -70,22 +95,52 @@ var MultisetClient = class {
     }
     return queryResult;
   }
+  async getGeoPoseComponents() {
+    if (typeof navigator === "undefined" || !("geolocation" in navigator) || !navigator.geolocation) {
+      return null;
+    }
+    try {
+      const position = await new Promise((resolve, reject) => {
+        navigator.geolocation.getCurrentPosition(resolve, reject, {
+          enableHighAccuracy: true,
+          timeout: 1e4,
+          maximumAge: 0
+        });
+      });
+      const { latitude, longitude, altitude } = position.coords;
+      const safeAltitude = typeof altitude === "number" && !Number.isNaN(altitude) ? altitude : 0;
+      return { latitude, longitude, altitude: safeAltitude };
+    } catch {
+      return null;
+    }
+  }
   async queryLocalization(frame, intrinsics) {
     var _a;
     const formData = new FormData();
-    formData.append("isRightHanded", "true");
-    formData.append("width", `${frame.width}`);
-    formData.append("height", `${frame.height}`);
-    formData.append("px", `${intrinsics.px}`);
-    formData.append("py", `${intrinsics.py}`);
-    formData.append("fx", `${intrinsics.fx}`);
-    formData.append("fy", `${intrinsics.fy}`);
-    formData.append("queryImage", frame.blob);
     if (this.config.mapType === "map") {
       formData.append("mapCode", this.config.code);
     } else {
       formData.append("mapSetCode", this.config.code);
     }
+    formData.append("isRightHanded", "true");
+    formData.append("fx", `${intrinsics.fx}`);
+    formData.append("fy", `${intrinsics.fy}`);
+    formData.append("px", `${intrinsics.px}`);
+    formData.append("py", `${intrinsics.py}`);
+    formData.append("width", `${frame.width}`);
+    formData.append("height", `${frame.height}`);
+    formData.append("queryImage", frame.blob);
+    if (this.config.geoCoordinatesInResponse) {
+      formData.append("geoCoordinatesInResponse", "true");
+    }
+    if (this.config.passGeoPose) {
+      const components = await this.getGeoPoseComponents();
+      if (components) {
+        const { latitude, longitude, altitude } = components;
+        const geoHint = `${latitude},${longitude},${altitude}`;
+        formData.append("geoHint", geoHint);
+      }
+    }
     try {
       const response = await axios.post(
         this.endpoints.queryUrl,
@@ -103,10 +158,17 @@ var MultisetClient = class {
       const result = {
         localizeData: data
       };
-      if ((_a = data.mapIds) == null ? void 0 : _a.length) {
-        const mapDetails = await this.fetchMapDetails(data.mapIds[0]);
-        if (mapDetails) {
-          result.mapDetails = mapDetails;
+      if (this.config.showMesh && this.config.mapType === "map" && ((_a = data.mapCodes) == null ? void 0 : _a.length)) {
+        const mapCode = data.mapCodes[0];
+        const cached = this.mapDetailsCache[mapCode];
+        if (cached) {
+          result.mapDetails = cached;
+        } else {
+          const mapDetails = await this.fetchMapDetails(mapCode);
+          if (mapDetails) {
+            this.mapDetailsCache[mapCode] = mapDetails;
+            result.mapDetails = mapDetails;
+          }
         }
       }
       return result;
@@ -115,10 +177,10 @@ var MultisetClient = class {
       return null;
     }
   }
-  async fetchMapDetails(mapId) {
+  async fetchMapDetails(mapCode) {
     try {
       const response = await axios.get(
-        `${this.endpoints.mapDetailsUrl}${mapId}`,
+        `${this.endpoints.mapDetailsUrl}${mapCode}`,
         {
           headers: {
             Authorization: `Bearer ${this.accessToken}`
@@ -148,59 +210,373 @@ var MultisetClient = class {
     }
   }
 };
+
+// src/lib/webxr/internal/cameraIntrinsics.ts
+function getCameraIntrinsics(projectionMatrix, viewport) {
+  const p = projectionMatrix;
+  const u0 = (1 - p[8]) * viewport.width / 2 + viewport.x;
+  const v0 = (1 - p[9]) * viewport.height / 2 + viewport.y;
+  const ax = viewport.width / 2 * p[0];
+  const ay = viewport.height / 2 * p[5];
+  return {
+    fx: ax,
+    fy: ay,
+    px: u0,
+    py: v0,
+    width: viewport.width,
+    height: viewport.height
+  };
+}
+
+// src/lib/webxr/internal/frameCapture.ts
+async function compressToJpeg(buffer, width, height, quality = 0.8) {
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return new Blob();
+  const imageData = new ImageData(new Uint8ClampedArray(buffer), width, height);
+  ctx.putImageData(imageData, 0, 0);
+  return new Promise((resolve) => {
+    canvas.toBlob((blob) => resolve(blob != null ? blob : new Blob()), "image/jpeg", quality);
+  });
+}
+async function getCameraTextureAsImage(renderer, webGLTexture, width, height) {
+  const gl = renderer.getContext();
+  if (!gl) return null;
+  const framebuffer = gl.createFramebuffer();
+  if (!framebuffer) return null;
+  let pixelBuffer;
+  try {
+    gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(
+      gl.FRAMEBUFFER,
+      gl.COLOR_ATTACHMENT0,
+      gl.TEXTURE_2D,
+      webGLTexture,
+      0
+    );
+    pixelBuffer = new Uint8Array(width * height * 4);
+    gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixelBuffer);
+  } finally {
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.deleteFramebuffer(framebuffer);
+  }
+  const flippedData = new Uint8ClampedArray(pixelBuffer.length);
+  for (let row = 0; row < height; row += 1) {
+    const sourceStart = row * width * 4;
+    const destStart = (height - row - 1) * width * 4;
+    flippedData.set(
+      pixelBuffer.subarray(sourceStart, sourceStart + width * 4),
+      destStart
+    );
+  }
+  const blob = await compressToJpeg(flippedData.buffer, width, height, 0.7);
+  if (!blob.size) {
+    return null;
+  }
+  return {
+    blob,
+    width,
+    height
+  };
+}
+var Experience = class {
+  constructor(canvas) {
+    this.renderer = new THREE3.WebGLRenderer({
+      canvas,
+      antialias: true,
+      alpha: true
+    });
+    this.renderer.setSize(window.innerWidth, window.innerHeight);
+    this.renderer.setPixelRatio(window.devicePixelRatio);
+    this.renderer.xr.enabled = true;
+    this.camera = new THREE3.PerspectiveCamera(
+      45,
+      window.innerWidth / window.innerHeight,
+      0.2,
+      1e4
+    );
+    this.scene = new THREE3.Scene();
+    this.setupLights();
+  }
+  setupLights() {
+    const light = new THREE3.HemisphereLight(16777215, 16314623, 1);
+    light.position.set(0.5, 2, 0.25);
+    this.scene.add(light);
+    const diLight = new THREE3.DirectionalLight("#7B2CBF");
+    diLight.position.set(0, 2, 0);
+    this.scene.add(diLight);
+  }
+  getScene() {
+    return this.scene;
+  }
+  getCamera() {
+    return this.camera;
+  }
+  getRenderer() {
+    return this.renderer;
+  }
+  resize() {
+    this.camera.aspect = window.innerWidth / window.innerHeight;
+    this.camera.updateProjectionMatrix();
+    this.renderer.setSize(window.innerWidth, window.innerHeight);
+  }
+  dispose() {
+    this.renderer.dispose();
+    this.scene = null;
+    this.camera = null;
+    this.renderer = null;
+  }
+};
+var VERTEX = `
+varying vec3 vWorldPosition;
+
+void main() {
+  vec4 worldPos = modelMatrix * vec4(position, 1.0);
+  vWorldPosition = worldPos.xyz;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}
+`;
+var FRAGMENT = `
+uniform vec3 uColor;
+uniform float uOpacity;
+uniform vec3 uGridColor;
+uniform float uGridScale;
+
+varying vec3 vWorldPosition;
+
+void main() {
+  vec2 coord = vWorldPosition.xz * uGridScale;
+  vec2 grid = abs(fract(coord - 0.5) - 0.5) / fwidth(coord);
+  float line = min(grid.x, grid.y) / 2.0;
+  float gridLine = 1.0 - min(line, 1.0);
+
+  vec3 base = uColor;
+  vec3 gridCol = uGridColor;
+  float alpha = mix(uOpacity, 1.0, gridLine);
+  vec3 color = mix(base, gridCol, gridLine);
+  gl_FragColor = vec4(color, alpha);
+}
+`;
+function createGridMaterial(options = {}) {
+  var _a, _b, _c, _d;
+  const color = (_a = options.color) != null ? _a : "#7B2CBF";
+  const opacity = (_b = options.opacity) != null ? _b : 0.6;
+  const gridColor = (_c = options.gridColor) != null ? _c : "#ffeb3b";
+  const gridScale = (_d = options.gridScale) != null ? _d : 2;
+  return new THREE3.ShaderMaterial({
+    vertexShader: VERTEX,
+    fragmentShader: FRAGMENT,
+    transparent: true,
+    side: THREE3.DoubleSide,
+    uniforms: {
+      uColor: { value: typeof color === "string" ? new THREE3.Color(color) : color },
+      uOpacity: { value: opacity },
+      uGridColor: { value: typeof gridColor === "string" ? new THREE3.Color(gridColor) : gridColor },
+      uGridScale: { value: gridScale }
+    }
+  });
+}
+
+// src/lib/webxr/mapMeshVisualizer.ts
+var LARGE_MAP_THRESHOLD = 50;
+var MapMeshVisualizer = class {
+  constructor(scene, client) {
+    this.scene = scene;
+    this.client = client;
+    this.meshGroup = new THREE3.Group();
+    this.meshGroup.visible = false;
+    this.scene.add(this.meshGroup);
+    this.dracoLoader = new DRACOLoader();
+    this.dracoLoader.setDecoderPath("/draco/");
+    this.gltfLoader = new GLTFLoader();
+    this.gltfLoader.setDRACOLoader(this.dracoLoader);
+  }
+  getMeshGroup() {
+    return this.meshGroup;
+  }
+  async ensureMeshLoaded(mapDetails) {
+    var _a, _b;
+    if (this.scene.getObjectByName(mapDetails._id)) {
+      return;
+    }
+    const meshKey = (_b = (_a = mapDetails.mapMesh) == null ? void 0 : _a.rawMesh) == null ? void 0 : _b.meshLink;
+    if (!meshKey) {
+      return;
+    }
+    const url = await this.client.downloadFile(meshKey);
+    if (!url) {
+      return;
+    }
+    const meshMaterial = createGridMaterial({
+      color: "#7B2CBF",
+      opacity: 0.6,
+      gridColor: "#ffeb3b",
+      gridScale: 2
+    });
+    await new Promise((resolve, reject) => {
+      this.gltfLoader.load(
+        url,
+        (gltf) => {
+          gltf.scene.traverse((child) => {
+            if (child.isMesh) {
+              child.material = meshMaterial;
+            }
+          });
+          const box = new THREE3.Box3().setFromObject(gltf.scene);
+          let size = box.getSize(new THREE3.Vector3()).length();
+          box.getCenter(new THREE3.Vector3());
+          if (size > LARGE_MAP_THRESHOLD) {
+            size = LARGE_MAP_THRESHOLD;
+            new THREE3.Vector3();
+          }
+          gltf.scene.name = mapDetails._id;
+          this.meshGroup.add(gltf.scene);
+          resolve();
+        },
+        void 0,
+        (error) => {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      );
+    });
+  }
+  applyMeshTransform(best, trackerSpace) {
+    const pose = best.localizeData;
+    const resPosition = new THREE3.Vector3(
+      pose.position.x,
+      pose.position.y,
+      pose.position.z
+    );
+    const resRotation = new THREE3.Quaternion(
+      pose.rotation.x,
+      pose.rotation.y,
+      pose.rotation.z,
+      pose.rotation.w
+    );
+    const responseMatrix = new THREE3.Matrix4();
+    responseMatrix.compose(resPosition, resRotation, new THREE3.Vector3(1, 1, 1));
+    const inverseResponseMatrix = responseMatrix.clone().invert();
+    const resultantMatrix = new THREE3.Matrix4();
+    resultantMatrix.multiplyMatrices(trackerSpace, inverseResponseMatrix);
+    const position = new THREE3.Vector3();
+    const rotation = new THREE3.Quaternion();
+    const scale = new THREE3.Vector3();
+    resultantMatrix.decompose(position, rotation, scale);
+    this.meshGroup.position.copy(position);
+    this.meshGroup.quaternion.copy(rotation);
+    this.meshGroup.scale.set(1, 1, 1);
+    this.meshGroup.visible = true;
+    this.meshGroup.updateMatrix();
+  }
+  dispose() {
+    this.meshGroup.traverse((child) => {
+      const mesh = child;
+      if (mesh.isMesh) {
+        mesh.geometry.dispose();
+        if (Array.isArray(mesh.material)) {
+          mesh.material.forEach((m) => m.dispose());
+        } else {
+          mesh.material.dispose();
+        }
+      }
+    });
+    this.scene.remove(this.meshGroup);
+    this.dracoLoader.dispose();
+  }
+};
+
+// src/lib/webxr/world/World.ts
+var World = class {
+  constructor(scene, client) {
+    this.meshVisualizer = new MapMeshVisualizer(scene, client);
+  }
+  async ensureMeshLoaded(mapDetails) {
+    await this.meshVisualizer.ensureMeshLoaded(mapDetails);
+  }
+  applyMeshTransform(best, trackerSpace) {
+    this.meshVisualizer.applyMeshTransform(best, trackerSpace);
+  }
+  dispose() {
+    this.meshVisualizer.dispose();
+  }
+};
+
+// src/lib/webxr/controller.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+var REQUEST_ATTEMPTS_MIN = 1;
+var REQUEST_ATTEMPTS_MAX = 5;
+var LOCALIZATION_INTERVAL_MIN = 1;
+var LOCALIZATION_INTERVAL_MAX = 5;
+var CONFIDENCE_THRESHOLD_MIN = 0.2;
+var CONFIDENCE_THRESHOLD_MAX = 0.8;
+var TRACKING_LOSS_FRAME_THRESHOLD = 60;
 var WebxrController = class {
   constructor(options) {
     this.options = options;
-    this.renderer = null;
-    this.camera = null;
-    this.scene = null;
-    this.animationLoop = null;
+    this.experience = null;
+    this.world = null;
     this.arButton = null;
     this.resizeHandler = null;
     this.isSessionActive = false;
+    this.trackingLossFrames = 0;
+    this.isLocalizing = false;
+    this.trackerSpace = null;
   }
   async initialize(buttonContainer) {
     var _a, _b, _c, _d;
-    if (this.renderer) {
+    if (this.experience) {
       return this.arButton;
     }
     if (!window.isSecureContext) {
       throw new Error("WebXR requires a secure context (HTTPS).");
     }
     const canvas = (_a = this.options.canvas) != null ? _a : document.createElement("canvas");
-    const renderer = new THREE.WebGLRenderer({
-      canvas,
-      antialias: true,
-      alpha: true
-    });
-    renderer.setSize(window.innerWidth, window.innerHeight);
-    renderer.setPixelRatio(window.devicePixelRatio);
-    renderer.xr.enabled = true;
+    this.experience = new Experience(canvas);
+    this.world = new World(this.experience.getScene(), this.options.client);
+    const renderer = this.experience.getRenderer();
+    const camera = this.experience.getCamera();
+    const scene = this.experience.getScene();
     renderer.xr.addEventListener("sessionstart", () => {
       var _a2, _b2;
       this.isSessionActive = true;
       (_b2 = (_a2 = this.options).onSessionStart) == null ? void 0 : _b2.call(_a2);
+      const cfg = this.options.client.getConfig();
+      if (cfg.autoLocalize) {
+        void this.localizeFrame();
+      }
     });
     renderer.xr.addEventListener("sessionend", () => {
       var _a2, _b2;
       this.isSessionActive = false;
       (_b2 = (_a2 = this.options).onSessionEnd) == null ? void 0 : _b2.call(_a2);
     });
-    const camera = new THREE.PerspectiveCamera(
-      45,
-      window.innerWidth / window.innerHeight,
-      0.2,
-      1e4
-    );
-    const scene = new THREE.Scene();
-    const animationLoop = () => {
+    const animationLoop = (_time, frame) => {
       renderer.render(scene, camera);
+      const cfg = this.options.client.getConfig();
+      if (cfg.relocalization && frame && !this.isLocalizing) {
+        const refSpace = renderer.xr.getReferenceSpace();
+        if (refSpace) {
+          const viewerPose = frame.getViewerPose(refSpace);
+          if (!viewerPose) {
+            this.trackingLossFrames += 1;
+            if (this.trackingLossFrames >= TRACKING_LOSS_FRAME_THRESHOLD) {
+              this.trackingLossFrames = 0;
+              void this.localizeFrame();
+            }
+          } else {
+            this.trackingLossFrames = 0;
+          }
+        }
+      }
     };
     renderer.setAnimationLoop(animationLoop);
     const resizeHandler = () => {
-      camera.aspect = window.innerWidth / window.innerHeight;
-      camera.updateProjectionMatrix();
-      renderer.setSize(window.innerWidth, window.innerHeight);
+      var _a2;
+      (_a2 = this.experience) == null ? void 0 : _a2.resize();
     };
     window.addEventListener("resize", resizeHandler);
     const overlayRoot = (_b = this.options.overlayRoot) != null ? _b : document.body;
@@ -212,51 +588,142 @@ var WebxrController = class {
     if (!buttonParent.contains(arButton)) {
       buttonParent.appendChild(arButton);
     }
-    this.renderer = renderer;
-    this.camera = camera;
-    this.scene = scene;
-    this.animationLoop = animationLoop;
     this.arButton = arButton;
     this.resizeHandler = resizeHandler;
     (_d = (_c = this.options).onARButtonCreated) == null ? void 0 : _d.call(_c, arButton);
     return arButton;
   }
   getScene() {
-    if (!this.scene) {
+    if (!this.experience) {
       throw new Error("Scene: WebXR controller has not been initialized.");
     }
-    return this.scene;
+    return this.experience.getScene();
   }
   getCamera() {
-    if (!this.camera) {
+    if (!this.experience) {
       throw new Error("Camera: WebXR controller has not been initialized.");
     }
-    return this.camera;
+    return this.experience.getCamera();
   }
   getRenderer() {
-    if (!this.renderer) {
+    if (!this.experience) {
       throw new Error("Renderer: WebXR controller has not been initialized.");
     }
-    return this.renderer;
+    return this.experience.getRenderer();
   }
   hasActiveSession() {
     var _a;
-    return this.isSessionActive && ((_a = this.renderer) == null ? void 0 : _a.xr.isPresenting) === true;
+    return this.isSessionActive && ((_a = this.experience) == null ? void 0 : _a.getRenderer().xr.isPresenting) === true;
   }
+  /**
+   * Runs a single-frame localization cycle: multiple attempts (per requestAttempts),
+   * picks best result by confidence, optionally validates against confidenceThreshold,
+   * and fires onLocalizationInit / onLocalizationSuccess / onLocalizationFailure.
+   * Aligns with Unity SingleFrameLocalizationManager.LocalizeFrame().
+   */
+  async localizeFrame() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    if (!this.experience) {
+      throw new Error("WebXR: WebXR controller has not been initialized.");
+    }
+    const renderer = this.experience.getRenderer();
+    const session = (_b = (_a = renderer.xr).getSession) == null ? void 0 : _b.call(_a);
+    if (!session) {
+      throw new Error(
+        "WebXR Session: No active WebXR session. Start AR before calling localizeFrame()."
+      );
+    }
+    const cfg = this.options.client.getConfig();
+    const requestAttempts = clamp(
+      (_c = cfg.requestAttempts) != null ? _c : 1,
+      REQUEST_ATTEMPTS_MIN,
+      REQUEST_ATTEMPTS_MAX
+    );
+    const localizationInterval = clamp(
+      (_d = cfg.localizationInterval) != null ? _d : 1,
+      LOCALIZATION_INTERVAL_MIN,
+      LOCALIZATION_INTERVAL_MAX
+    );
+    const confidenceCheck = (_e = cfg.confidenceCheck) != null ? _e : false;
+    const confidenceThreshold = clamp(
+      (_f = cfg.confidenceThreshold) != null ? _f : 0.5,
+      CONFIDENCE_THRESHOLD_MIN,
+      CONFIDENCE_THRESHOLD_MAX
+    );
+    (_g = cfg.onLocalizationInit) == null ? void 0 : _g.call(cfg);
+    this.isLocalizing = true;
+    const results = [];
+    const MAX_FRAME_ATTEMPTS = requestAttempts * 3;
+    try {
+      let apiCallsDone = 0;
+      let frameAttempts = 0;
+      while (apiCallsDone < requestAttempts && frameAttempts < MAX_FRAME_ATTEMPTS) {
+        frameAttempts++;
+        try {
+          const { result, apiCalled } = await this.captureFrame();
+          if (apiCalled) {
+            apiCallsDone++;
+            if ((_h = result == null ? void 0 : result.localizeData) == null ? void 0 : _h.poseFound) {
+              results.push(result);
+            }
+          }
+        } catch {
+          apiCallsDone++;
+        }
+        if (apiCallsDone < requestAttempts && frameAttempts < MAX_FRAME_ATTEMPTS) {
+          await new Promise(
+            (r) => setTimeout(r, localizationInterval * 1e3)
+          );
+        }
+      }
+    } finally {
+      this.isLocalizing = false;
+    }
+    const best = results.length ? results.sort(
+      (a, b) => {
+        var _a2, _b2;
+        return ((_a2 = b.localizeData.confidence) != null ? _a2 : 0) - ((_b2 = a.localizeData.confidence) != null ? _b2 : 0);
+      }
+    )[0] : null;
+    const accepted = best && (!confidenceCheck || ((_i = best.localizeData.confidence) != null ? _i : 0) >= confidenceThreshold);
+    if (accepted && best) {
+      (_j = cfg.onLocalizationSuccess) == null ? void 0 : _j.call(cfg, best);
+      if (cfg.showMesh && best.mapDetails && this.world && this.trackerSpace) {
+        try {
+          await this.world.ensureMeshLoaded(best.mapDetails);
+          this.world.applyMeshTransform(best, this.trackerSpace);
+        } catch {
+        }
+      }
+      return best;
+    }
+    const reason = !best ? "All attempts failed to produce a pose." : confidenceCheck ? `Best confidence ${(_k = best.localizeData.confidence) != null ? _k : 0} below threshold ${confidenceThreshold}.` : void 0;
+    (_l = cfg.onLocalizationFailure) == null ? void 0 : _l.call(cfg, reason);
+    return null;
+  }
+  /**
+   * Internal: captures one frame and calls the localization API. Returns the
+   * result and whether the API was actually invoked — used by localizeFrame()
+   * to count only real API calls toward requestAttempts (frames with no camera
+   * image are skipped).
+   */
   async captureFrame() {
     var _a, _b;
-    const renderer = this.renderer;
-    const camera = this.camera;
-    if (!renderer || !camera) {
+    if (!this.experience) {
       throw new Error("WebXR: WebXR controller has not been initialized.");
     }
+    const renderer = this.experience.getRenderer();
     const session = (_b = (_a = renderer.xr).getSession) == null ? void 0 : _b.call(_a);
     if (!session) {
-      throw new Error("WebXR Session: No active WebXR session. Start AR before capturing.");
+      throw new Error(
+        "WebXR Session: No active WebXR session. Start AR before capturing."
+      );
     }
     const referenceSpace = renderer.xr.getReferenceSpace();
     if (!referenceSpace) {
-      throw new Error("WebXR Reference Space: Unable to acquire XR reference space.");
+      throw new Error(
+        "WebXR Reference Space: Unable to acquire XR reference space."
+      );
     }
     const gl = renderer.getContext();
     return new Promise((resolve, reject) => {
@@ -265,7 +732,7 @@ var WebxrController = class {
         try {
           const viewerPose = xrFrame.getViewerPose(referenceSpace);
           if (!viewerPose) {
-            resolve(null);
+            resolve({ result: null, apiCalled: false });
             return;
           }
           for (const view of viewerPose.views) {
@@ -292,15 +759,16 @@ var WebxrController = class {
               y: 0
             });
             if (frameData && intrinsics) {
+              this.trackerSpace = new THREE3.Matrix4().fromArray(view.transform.matrix);
               const result = await this.options.client.localizeWithFrame(
                 frameData,
                 intrinsics
               );
-              resolve(result);
+              resolve({ result, apiCalled: true });
               return;
             }
           }
-          resolve(null);
+          resolve({ result: null, apiCalled: false });
         } catch (error) {
           reject(error);
         } finally {
@@ -313,85 +781,22 @@ var WebxrController = class {
     });
   }
   dispose() {
-    var _a;
+    var _a, _b, _c, _d;
     if (this.resizeHandler) {
       window.removeEventListener("resize", this.resizeHandler);
     }
-    if (this.renderer) {
-      this.renderer.dispose();
-      this.renderer = null;
-    }
-    this.animationLoop = null;
-    this.camera = null;
-    this.scene = null;
-    if ((_a = this.arButton) == null ? void 0 : _a.parentElement) {
+    (_a = this.experience) == null ? void 0 : _a.getRenderer().setAnimationLoop(null);
+    (_b = this.experience) == null ? void 0 : _b.dispose();
+    this.experience = null;
+    (_c = this.world) == null ? void 0 : _c.dispose();
+    this.world = null;
+    this.trackingLossFrames = 0;
+    if ((_d = this.arButton) == null ? void 0 : _d.parentElement) {
       this.arButton.parentElement.removeChild(this.arButton);
     }
     this.arButton = null;
   }
 };
-function getCameraIntrinsics(projectionMatrix, viewport) {
-  const p = projectionMatrix;
-  const u0 = (1 - p[8]) * viewport.width / 2 + viewport.x;
-  const v0 = (1 - p[9]) * viewport.height / 2 + viewport.y;
-  const ax = viewport.width / 2 * p[0];
-  const ay = viewport.height / 2 * p[5];
-  return {
-    fx: ax,
-    fy: ay,
-    px: u0,
-    py: v0,
-    width: viewport.width,
-    height: viewport.height
-  };
-}
-async function compressToJpeg(buffer, width, height, quality = 0.8) {
-  const canvas = document.createElement("canvas");
-  const ctx = canvas.getContext("2d");
-  canvas.width = width;
-  canvas.height = height;
-  const imageData = new ImageData(new Uint8ClampedArray(buffer), width, height);
-  ctx == null ? void 0 : ctx.putImageData(imageData, 0, 0);
-  return new Promise((resolve) => {
-    canvas.toBlob((blob) => resolve(blob != null ? blob : new Blob()), "image/jpeg", quality);
-  });
-}
-async function getCameraTextureAsImage(renderer, webGLTexture, width, height) {
-  const gl = renderer.getContext();
-  if (!gl) return null;
-  const framebuffer = gl.createFramebuffer();
-  if (!framebuffer) return null;
-  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-  gl.framebufferTexture2D(
-    gl.FRAMEBUFFER,
-    gl.COLOR_ATTACHMENT0,
-    gl.TEXTURE_2D,
-    webGLTexture,
-    0
-  );
-  const pixelBuffer = new Uint8Array(width * height * 4);
-  gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixelBuffer);
-  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-  gl.deleteFramebuffer(framebuffer);
-  const flippedData = new Uint8ClampedArray(pixelBuffer.length);
-  for (let row = 0; row < height; row += 1) {
-    const sourceStart = row * width * 4;
-    const destStart = (height - row - 1) * width * 4;
-    flippedData.set(
-      pixelBuffer.subarray(sourceStart, sourceStart + width * 4),
-      destStart
-    );
-  }
-  const blob = await compressToJpeg(flippedData.buffer, width, height, 0.7);
-  if (!blob.size) {
-    return null;
-  }
-  return {
-    blob,
-    width,
-    height
-  };
-}
 
 export { DEFAULT_ENDPOINTS, MultisetClient, WebxrController };
 //# sourceMappingURL=index.js.map