gps-plus-slam-app-framework 1.3.0 → 1.7.0

package/dist/ar/qr-pose.d.ts

@@ -0,0 +1,2 @@
+import { _ as solveQrPose, a as QrPoseSolution, c as SolveQrPoseInput, d as intrinsicsFromProjection, f as invertPose, g as signedQuadArea, h as reprojectionErrorPx, i as Pose, l as buildObjectPoints, m as qrInCameraFromOpenCv, n as OpenCvPnpResult, o as QuadValidation, p as projectViewPoint, r as Point2, s as SolvePnpSquare, t as CameraIntrinsics, u as composePose, v as transformPoint, y as validateQuad } from "../qr-pose-D2rfu5DA.js";
+export { CameraIntrinsics, OpenCvPnpResult, Point2, Pose, QrPoseSolution, QuadValidation, SolvePnpSquare, SolveQrPoseInput, buildObjectPoints, composePose, intrinsicsFromProjection, invertPose, projectViewPoint, qrInCameraFromOpenCv, reprojectionErrorPx, signedQuadArea, solveQrPose, transformPoint, validateQuad };

package/dist/ar/qr-pose.js

@@ -0,0 +1,267 @@
+import { quat, vec3 } from "gl-matrix";
+//#region ../src/ar/qr-pose.ts
+/**
+* QR pose math — Phase 1 of the QR-code detection & 3D-tracking plan.
+*
+* Pure, device-free, OpenCV-free transforms shared by every later phase:
+* - object-point builder for a centered planar square (the `solvePnP` model),
+* - camera intrinsics derived from the rendered view's projection matrix,
+* - the OpenCV camera frame (+x right, +y DOWN, +z FORWARD) → WebXR camera
+*   frame (+x right, +y UP, −z forward) conversion of a solved pose,
+* - rigid pose compose/invert to lift a QR-in-camera pose into raw-WebXR
+*   ("odom") space under `arWorldGroup`,
+* - quad winding validation (the mirror/degenerate guard the briefs warn about),
+* - reprojection error (the on-device verification gate's quality metric).
+*
+* The heavy `solvePnP` itself is injected via {@link SolvePnpSquare} so this
+* module — and its tests — need no OpenCV. See qr-pose.ts.md for the full
+* convention rationale and the OpenCV↔WebXR derivation.
+*
+* Convention notes (single source of truth):
+* - Image/pixel coordinates have a TOP-LEFT origin, x right, y DOWN — matching
+*   `depth-unprojection.ts`, `BarcodeDetector.cornerPoints`, and OpenCV.
+* - The QR-local object frame is +x right, +y UP, +z out of the printed face;
+*   the centered square lies on z = 0. Corner order is TL, TR, BR, BL as read
+*   on the printed symbol (carries the QR's reading orientation → pose yaw).
+* - `solvePnP` maps object→camera in the OpenCV frame: p_cam = R·p_obj + t.
+*   WebXR camera = Rx(π)·(OpenCV camera); Rx(π) = diag(1,−1,−1) is a proper
+*   rotation (det = +1), so the converted pose stays a rigid motion.
+*/
+const DEFAULT_MAX_REPROJECTION_ERROR_PX = 4;
+/**
+* Build the 4 object points of a centered planar square of side `sizeM`, in
+* the QR-local frame (+x right, +y up, z = 0), ordered TL, TR, BR, BL to match
+* the detector's symbol reading order.
+*/
+function buildObjectPoints(sizeM) {
+	if (!(sizeM > 0) || !Number.isFinite(sizeM)) throw new RangeError(`qr-pose: sizeM must be a positive number, got ${sizeM}`);
+	const h = sizeM / 2;
+	return [
+		[
+			-h,
+			h,
+			0
+		],
+		[
+			h,
+			h,
+			0
+		],
+		[
+			h,
+			-h,
+			0
+		],
+		[
+			-h,
+			-h,
+			0
+		]
+	];
+}
+/**
+* Derive pinhole intrinsics (pixels) from a column-major GL projection matrix
+* for a detector frame of `width`×`height`. Valid for an axis-aligned frustum
+* (no skew); principal point uses the TOP-LEFT-origin pixel convention.
+*
+* Derivation (see qr-pose.ts.md): for clip = P·v_view and pixel
+* px = (ndc.x+1)·W/2, py = (1−ndc.y)·H/2 with ndc = clip.xy / (−Z):
+*   fx = P[0]·W/2, fy = P[5]·H/2, cx = (1−P[8])·W/2, cy = (1+P[9])·H/2.
+*/
+function intrinsicsFromProjection(projection, width, height) {
+	if (!projection || projection.length !== 16) throw new RangeError("qr-pose: projection must be a 16-element matrix");
+	if (!(width > 0) || !(height > 0)) throw new RangeError("qr-pose: width and height must be positive");
+	return {
+		fx: projection[0] * width / 2,
+		fy: projection[5] * height / 2,
+		cx: (1 - projection[8]) * width / 2,
+		cy: (1 + projection[9]) * height / 2
+	};
+}
+/**
+* Project a point given in the WebXR camera frame (+x right, +y up, −z forward)
+* to a pixel (top-left origin). Returns `null` for points not strictly in front
+* of the camera (z ≥ 0) or non-finite results.
+*/
+function projectViewPoint(pointInCamera, intrinsics) {
+	const [x, y, z] = pointInCamera;
+	const depth = -z;
+	if (!(depth > 0) || !Number.isFinite(depth)) return null;
+	const px = intrinsics.cx + intrinsics.fx * x / depth;
+	const py = intrinsics.cy - intrinsics.fy * y / depth;
+	return Number.isFinite(px) && Number.isFinite(py) ? {
+		x: px,
+		y: py
+	} : null;
+}
+/**
+* Convert a solved OpenCV pose (object→OpenCV-camera) into the QR pose in the
+* WebXR camera frame. Left-multiply by Rx(π): rotation = Rx(π)·R, position =
+* Rx(π)·t = (t0, −t1, −t2).
+*/
+function qrInCameraFromOpenCv(pnp) {
+	const { rvec, tvec } = pnp;
+	const angle = Math.hypot(rvec[0], rvec[1], rvec[2]);
+	const qR = quat.create();
+	if (angle > 1e-12) {
+		const axis = vec3.fromValues(rvec[0] / angle, rvec[1] / angle, rvec[2] / angle);
+		quat.setAxisAngle(qR, axis, angle);
+	}
+	const rxPi = quat.fromValues(1, 0, 0, 0);
+	const qWorld = quat.multiply(quat.create(), rxPi, qR);
+	quat.normalize(qWorld, qWorld);
+	return {
+		rotation: [
+			qWorld[0],
+			qWorld[1],
+			qWorld[2],
+			qWorld[3]
+		],
+		position: [
+			tvec[0],
+			-tvec[1],
+			-tvec[2]
+		]
+	};
+}
+/** Compose two rigid poses: result = parent ∘ child (child expressed in parent). */
+function composePose(parent, child) {
+	const pq = quat.fromValues(parent.rotation[0], parent.rotation[1], parent.rotation[2], parent.rotation[3]);
+	const cq = quat.fromValues(child.rotation[0], child.rotation[1], child.rotation[2], child.rotation[3]);
+	const rq = quat.multiply(quat.create(), pq, cq);
+	quat.normalize(rq, rq);
+	const childPos = vec3.fromValues(child.position[0], child.position[1], child.position[2]);
+	const rotated = vec3.transformQuat(vec3.create(), childPos, pq);
+	return {
+		rotation: [
+			rq[0],
+			rq[1],
+			rq[2],
+			rq[3]
+		],
+		position: [
+			rotated[0] + parent.position[0],
+			rotated[1] + parent.position[1],
+			rotated[2] + parent.position[2]
+		]
+	};
+}
+/** Invert a rigid pose: if pose maps A→B, the result maps B→A. */
+function invertPose(pose) {
+	const q = quat.fromValues(pose.rotation[0], pose.rotation[1], pose.rotation[2], pose.rotation[3]);
+	const inv = quat.invert(quat.create(), q);
+	quat.normalize(inv, inv);
+	const p = vec3.fromValues(pose.position[0], pose.position[1], pose.position[2]);
+	const negRotated = vec3.transformQuat(vec3.create(), p, inv);
+	return {
+		rotation: [
+			inv[0],
+			inv[1],
+			inv[2],
+			inv[3]
+		],
+		position: [
+			-negRotated[0],
+			-negRotated[1],
+			-negRotated[2]
+		]
+	};
+}
+/**
+* Signed area of the quad TL→TR→BR→BL via the shoelace formula, in image
+* pixels (top-left origin, y down). A front-facing QR imaged in symbol order is
+* clockwise on screen → POSITIVE signed area in this y-down convention. A
+* negative value means the winding is reversed (mirrored / wrong corner order)
+* — the #1 pose bug the briefs warn about.
+*/
+function signedQuadArea(corners) {
+	let sum = 0;
+	const n = corners.length;
+	for (let i = 0; i < n; i++) {
+		const a = corners[i];
+		const b = corners[(i + 1) % n];
+		if (a === void 0 || b === void 0) continue;
+		sum += a.x * b.y - b.x * a.y;
+	}
+	return sum / 2;
+}
+/**
+* Validate the 4 detected corners (assumed ordered TL, TR, BR, BL). Rejects a
+* mirrored winding and degenerate (tiny / collinear) quads. This does NOT
+* re-sort by image position — that would destroy the reading orientation the
+* detector encodes; it only guards the known failure modes.
+*/
+function validateQuad(corners, options = {}) {
+	const minAreaPx2 = options.minAreaPx2 ?? 64;
+	if (corners.length !== 4 || corners.some((c) => !Number.isFinite(c.x) || !Number.isFinite(c.y))) return {
+		ok: false,
+		mirrored: false,
+		degenerate: true,
+		areaPx2: 0
+	};
+	const signed = signedQuadArea(corners);
+	const areaPx2 = Math.abs(signed);
+	const mirrored = signed < 0;
+	const degenerate = areaPx2 < minAreaPx2;
+	return {
+		ok: !mirrored && !degenerate,
+		mirrored,
+		degenerate,
+		areaPx2
+	};
+}
+/**
+* RMS reprojection error (pixels): project the object points through
+* `qrPoseInCamera` (WebXR frame) and the pinhole model, compare to the detected
+* image points. `Infinity` if any point falls behind the camera.
+*/
+function reprojectionErrorPx(objectPoints, imagePoints, qrPoseInCamera, intrinsics) {
+	if (objectPoints.length !== imagePoints.length || objectPoints.length === 0) return Infinity;
+	let sumSq = 0;
+	for (let i = 0; i < objectPoints.length; i++) {
+		const obj = objectPoints[i];
+		const img = imagePoints[i];
+		if (obj === void 0 || img === void 0) return Infinity;
+		const projected = projectViewPoint(transformPoint(obj, qrPoseInCamera), intrinsics);
+		if (!projected) return Infinity;
+		const dx = projected.x - img.x;
+		const dy = projected.y - img.y;
+		sumSq += dx * dx + dy * dy;
+	}
+	return Math.sqrt(sumSq / objectPoints.length);
+}
+/** Apply a rigid pose to a point: result = rotation·p + position. */
+function transformPoint(point, pose) {
+	const q = quat.fromValues(pose.rotation[0], pose.rotation[1], pose.rotation[2], pose.rotation[3]);
+	const p = vec3.fromValues(point[0], point[1], point[2]);
+	const r = vec3.transformQuat(vec3.create(), p, q);
+	return [
+		r[0] + pose.position[0],
+		r[1] + pose.position[1],
+		r[2] + pose.position[2]
+	];
+}
+/**
+* Full pipeline: detected corners → QR pose in raw-WebXR/odom space. Validates
+* the quad, solves PnP (injected), converts OpenCV→WebXR, composes with the
+* camera pose, and gates on reprojection error. Returns `null` when the
+* detection is rejected at any stage.
+*/
+function solveQrPose(input) {
+	const { imagePoints, sizeM, intrinsics, cameraPose, solver, maxReprojectionErrorPx = DEFAULT_MAX_REPROJECTION_ERROR_PX } = input;
+	if (!validateQuad(imagePoints).ok) return null;
+	const objectPoints = buildObjectPoints(sizeM);
+	const pnp = solver.solve(objectPoints, imagePoints, intrinsics);
+	if (!pnp) return null;
+	if (!pnp.rvec.every(Number.isFinite) || !pnp.tvec.every(Number.isFinite) || pnp.tvec[2] <= 0) return null;
+	const qrPoseInCamera = qrInCameraFromOpenCv(pnp);
+	const reprojectionErrorPx_ = reprojectionErrorPx(objectPoints, imagePoints, qrPoseInCamera, intrinsics);
+	if (!(reprojectionErrorPx_ <= maxReprojectionErrorPx)) return null;
+	return {
+		qrPoseWorld: composePose(cameraPose, qrPoseInCamera),
+		qrPoseInCamera,
+		reprojectionErrorPx: reprojectionErrorPx_
+	};
+}
+//#endregion
+export { buildObjectPoints, composePose, intrinsicsFromProjection, invertPose, projectViewPoint, qrInCameraFromOpenCv, reprojectionErrorPx, signedQuadArea, solveQrPose, transformPoint, validateQuad };

package/dist/ar/qr-size-depth-context.d.ts

@@ -0,0 +1,3 @@
+import { n as QrSizeDepthContext } from "../qr-size-measurer-DQdAsid1.js";
+import { t as createQrSizeDepthContext } from "../qr-size-depth-context-CeAG53fy.js";
+export { QrSizeDepthContext, createQrSizeDepthContext };

package/dist/ar/qr-size-depth-context.js

@@ -0,0 +1,42 @@
+import { createDepthUnprojector } from "./depth-unprojection.js";
+import { createDepthGridLookup } from "./depth-grid-lookup.js";
+//#region ../src/ar/qr-size-depth-context.ts
+/**
+* `createQrSizeDepthContext` — build a {@link QrSizeDepthContext} (unprojector +
+* bilinear depth-grid lookup) from one {@link DepthSample}.
+*
+* This is the **shared** depth-context constructor for the QR sizing path. Both
+* consumers used to wire it independently:
+*   - the QR-tracking demo's `seams.getDepthContext` (live latest sample), and
+*   - the Recorder live-QR `qr-depth-resolver.contextFromSample` (as-of join).
+* They were byte-for-byte the same `createDepthUnprojector` +
+* `createDepthGridLookup` + `depthAt` wiring — a divergence risk (e.g. one
+* switching nearest↔bilinear would silently make the two apps measure different
+* QR sizes). Centralizing it here keeps them identical by construction; each
+* consumer composes whatever extra it needs on top (the demo adds `cameraPose` +
+* `projectionMatrix` for the PnP intrinsics).
+*
+* Deep-imported via `…/ar/qr-size-depth-context` (NOT the `…/ar` barrel) so the
+* Recorder's partially-mocked wiring tests don't pull heavy transitive deps —
+* same rationale as `qr-depth-resolver` / `qr-debug-view`.
+*
+* @see qr-size-measurer.ts — the `QrSizeDepthContext` consumer (size measurement).
+* @see depth-unprojection.ts / depth-grid-lookup.ts — the pieces this composes.
+*/
+/**
+* Build a {@link QrSizeDepthContext} from one depth sample, or `null` when it has
+* no projection matrix / a singular one (the unprojector cannot be built). The
+* grid lookup is **bilinear** (depth varies smoothly across a small QR face,
+* rather than snapping to one nearest node). Best-effort — never throws.
+*/
+function createQrSizeDepthContext(sample) {
+	const unprojector = createDepthUnprojector(sample.cameraPos, sample.cameraRot, sample.projectionMatrix);
+	if (!unprojector) return null;
+	const lookup = createDepthGridLookup(sample.points);
+	return {
+		unprojector,
+		depthAt: (x, y) => lookup.depthAt(x, y)
+	};
+}
+//#endregion
+export { createQrSizeDepthContext };

package/dist/ar/qr-size-measurer.d.ts

@@ -0,0 +1,2 @@
+import { a as QrSizeMeasurerOptions, i as QrSizeMeasurer, n as QrSizeDepthContext, o as createQrSizeMeasurer, r as QrSizeMeasurement, t as ImageSize } from "../qr-size-measurer-DQdAsid1.js";
+export { ImageSize, QrSizeDepthContext, QrSizeMeasurement, QrSizeMeasurer, QrSizeMeasurerOptions, createQrSizeMeasurer };

package/dist/ar/qr-size-measurer.js

@@ -0,0 +1,2 @@
+import { t as createQrSizeMeasurer } from "../qr-size-measurer-DLb33geH.js";
+export { createQrSizeMeasurer };

package/dist/ar/replay-scene.d.ts

@@ -1,2 +1,2 @@
-import { a as getCameraFollower, c as getReplayState, d as updateOrbitTarget, i as getAlignmentLerper, l as initReplayScene, n as ReplaySceneState, o as getCameraMode, r as disposeReplayScene, s as getCss3dManager, t as CameraMode, u as toggleCameraMode } from "../replay-scene-Bw58VL6p.js";
+import { a as getCameraFollower, c as getReplayState, d as updateOrbitTarget, i as getAlignmentLerper, l as initReplayScene, n as ReplaySceneState, o as getCameraMode, r as disposeReplayScene, s as getCss3dManager, t as CameraMode, u as toggleCameraMode } from "../replay-scene-DBlDrV_x.js";
 export { CameraMode, ReplaySceneState, disposeReplayScene, getAlignmentLerper, getCameraFollower, getCameraMode, getCss3dManager, getReplayState, initReplayScene, toggleCameraMode, updateOrbitTarget };

package/dist/ar/replay-scene.js

@@ -1,5 +1,5 @@
 import { createLogger } from "../utils/logger.js";
-import { C as setArWorldGroup, O as setScene, S as setArPose, r as createSceneHierarchy, w as setCamera } from "../webxr-session-TIaD883f.js";
+import { D as setCamera, E as setArWorldGroup, N as setScene, T as setArPose, i as createSceneHierarchy } from "../webxr-session-DG-eNfny.js";
 import { createCss3dRendererManager } from "../visualization/css3d-renderer-manager.js";
 import { createCameraFollower } from "../visualization/camera-follower.js";
 import { createAlignmentLerper } from "../visualization/alignment-lerper.js";

package/dist/ar/scene-node-names.d.ts

@@ -1,2 +1,2 @@
-import { t as SCENE_NODE } from "../scene-node-names-Bu0S66H1.js";
+import { t as SCENE_NODE } from "../scene-node-names-BiShOQDB.js";
 export { SCENE_NODE };

package/dist/ar/webxr-nue-basis.d.ts

@@ -1,2 +1,2 @@
-import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-CqKQmZzT.js";
+import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-3nfjDJJp.js";
 export { WEBXR_TO_NUE };

package/dist/ar/webxr-session.d.ts

@@ -1,4 +1,4 @@
-import { i as DepthSample, t as ARPose } from "../ar-types-Dan1MVTi.js";
-import { n as CapturedImage } from "../image-capture-qAZ5Fh5X.js";
-import { A as setScene, C as resetWebXRState, D as setDepthCaptureCallback, E as setCamera, F as shouldLogCameraAccessDiagnostic, I as startDepthCapture, L as startImageCapture, M as setTrackingLostCallback, N as setTrackingRecoveredCallback, O as setFrameCallback, P as setTrackingStore, R as stopDepthCapture, S as nueQuaternionToWebXR, T as setArWorldGroup, _ as getXrCameraFromPose, a as createSceneHierarchy, b as isXRCameraLike, c as extractResetTransformData, d as getCamera, f as getCurrentArPose, g as getScene, h as getLiveCss3dManager, i as buildSessionOptions, j as setTrackingCallbacks, k as setImageCaptureCallback, l as getArPose, m as getImageCaptureFrameCount, n as TrackingSubscribableStore, o as endARSession, p as getDepthSampleCount, r as applyAlignmentMatrix, s as extractPoseFromViewer, t as SessionFeatureOptions, u as getArWorldGroup, v as initAR, w as setArPose, x as nuePositionToWebXR, y as isWebXRSupported, z as stopImageCapture } from "../webxr-session-GjZ2BIpS.js";
-export { ARPose, CapturedImage, DepthSample, SessionFeatureOptions, TrackingSubscribableStore, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture };
+import { i as DepthSample, t as ARPose } from "../ar-types-BFX2r1wk.js";
+import { n as CapturedImage } from "../image-capture-CNZDrQXG.js";
+import { A as setCamera, B as setTrackingStore, C as isWebXRSupported, D as resetWebXRState, E as nueQuaternionToWebXR, F as setImageQualityAnalyzer, G as stopCameraFrameCapture, H as startCameraFrameCapture, I as setScene, K as stopDepthCapture, L as setTrackingCallbacks, M as setDepthCaptureCallback, N as setFrameCallback, O as setArPose, P as setImageCaptureCallback, R as setTrackingLostCallback, S as initAR, T as nuePositionToWebXR, U as startDepthCapture, V as shouldLogCameraAccessDiagnostic, W as startImageCapture, _ as getDepthSampleCount, a as applyAlignmentMatrix, b as getScene, c as endARSession, d as getArPose, f as getArWorldGroup, g as getCurrentArPose, h as getCameraFrameCount, i as TrackingSubscribableStore, j as setCameraFrameCallback, k as setArWorldGroup, l as extractPoseFromViewer, m as getCameraFrameCaptureSize, n as DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, o as buildSessionOptions, p as getCamera, q as stopImageCapture, r as SessionFeatureOptions, s as createSceneHierarchy, t as CameraFrameCaptureConfig, u as extractResetTransformData, v as getImageCaptureFrameCount, w as isXRCameraLike, x as getXrCameraFromPose, y as getLiveCss3dManager, z as setTrackingRecoveredCallback } from "../webxr-session-Do5L6G3B.js";
+export { ARPose, CameraFrameCaptureConfig, CapturedImage, DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, DepthSample, SessionFeatureOptions, TrackingSubscribableStore, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCameraFrameCaptureSize, getCameraFrameCount, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setCameraFrameCallback, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setImageQualityAnalyzer, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startCameraFrameCapture, startDepthCapture, startImageCapture, stopCameraFrameCapture, stopDepthCapture, stopImageCapture };

package/dist/ar/webxr-session.js

@@ -1,2 +1,2 @@
-import { A as setTrackingLostCallback, C as setArWorldGroup, D as setImageCaptureCallback, E as setFrameCallback, F as startImageCapture, I as stopDepthCapture, L as stopImageCapture, M as setTrackingStore, N as shouldLogCameraAccessDiagnostic, O as setScene, P as startDepthCapture, S as setArPose, T as setDepthCaptureCallback, _ as isWebXRSupported, a as extractPoseFromViewer, b as nueQuaternionToWebXR, c as getArWorldGroup, d as getDepthSampleCount, f as getImageCaptureFrameCount, g as initAR, h as getXrCameraFromPose, i as endARSession, j as setTrackingRecoveredCallback, k as setTrackingCallbacks, l as getCamera, m as getScene, n as buildSessionOptions, o as extractResetTransformData, p as getLiveCss3dManager, r as createSceneHierarchy, s as getArPose, t as applyAlignmentMatrix, u as getCurrentArPose, v as isXRCameraLike, w as setCamera, x as resetWebXRState, y as nuePositionToWebXR } from "../webxr-session-TIaD883f.js";
-export { applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture };
+import { A as setFrameCallback, B as startDepthCapture, C as nueQuaternionToWebXR, D as setCamera, E as setArWorldGroup, F as setTrackingLostCallback, H as stopCameraFrameCapture, I as setTrackingRecoveredCallback, L as setTrackingStore, M as setImageQualityAnalyzer, N as setScene, O as setCameraFrameCallback, P as setTrackingCallbacks, R as shouldLogCameraAccessDiagnostic, S as nuePositionToWebXR, T as setArPose, U as stopDepthCapture, V as startImageCapture, W as stopImageCapture, _ as getScene, a as endARSession, b as isWebXRSupported, c as getArPose, d as getCameraFrameCaptureSize, f as getCameraFrameCount, g as getLiveCss3dManager, h as getImageCaptureFrameCount, i as createSceneHierarchy, j as setImageCaptureCallback, k as setDepthCaptureCallback, l as getArWorldGroup, m as getDepthSampleCount, n as applyAlignmentMatrix, o as extractPoseFromViewer, p as getCurrentArPose, r as buildSessionOptions, s as extractResetTransformData, t as DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, u as getCamera, v as getXrCameraFromPose, w as resetWebXRState, x as isXRCameraLike, y as initAR, z as startCameraFrameCapture } from "../webxr-session-DG-eNfny.js";
+export { DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCameraFrameCaptureSize, getCameraFrameCount, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setCameraFrameCallback, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setImageQualityAnalyzer, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startCameraFrameCapture, startDepthCapture, startImageCapture, stopCameraFrameCapture, stopDepthCapture, stopImageCapture };

package/dist/ar/xr-camera-texture.d.ts

@@ -1,2 +1,2 @@
-import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-DBwCaKTd.js";
+import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-Cva1q3Qj.js";
 export { CameraTextureResult, RendererLike, XRCameraLike, acquireCameraTexture };

package/dist/ar/xr-error-handler.d.ts

@@ -1,2 +1,2 @@
-import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-C0AQRmxs.js";
+import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-CtvHpjfm.js";
 export { XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, getXrErrorMessage };

package/dist/ar/xr-frame-loop.d.ts

@@ -1,2 +1,2 @@
-import { a as runXrFrameUpdates, i as registerXrFrameUpdate, n as XrFrameUpdate, r as clearXrFrameUpdates, t as XrFrameContext } from "../xr-frame-loop-BtYytZJg.js";
+import { a as runXrFrameUpdates, i as registerXrFrameUpdate, n as XrFrameUpdate, r as clearXrFrameUpdates, t as XrFrameContext } from "../xr-frame-loop-DIYtRcUa.js";
 export { XrFrameContext, XrFrameUpdate, clearXrFrameUpdates, registerXrFrameUpdate, runXrFrameUpdates };