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

package/dist/ar/planar-pnp.js

@@ -0,0 +1,425 @@
+//#region ../src/ar/planar-pnp.ts
+const EPS = 1e-12;
+/**
+* Solve the dense square linear system `A·x = b` by Gaussian elimination with
+* partial pivoting. `A` is `n×n` ROW-MAJOR (length n²), `b` is length n. Returns
+* the solution, or `null` when the matrix is singular (no unique solution).
+*/
+function solveLinear(A, b) {
+	const n = b.length;
+	if (A.length !== n * n || n === 0) return null;
+	const m = A.slice();
+	const y = b.slice();
+	for (let col = 0; col < n; col++) {
+		let pivot = col;
+		let best = Math.abs(m[col * n + col]);
+		for (let row = col + 1; row < n; row++) {
+			const v = Math.abs(m[row * n + col]);
+			if (v > best) {
+				best = v;
+				pivot = row;
+			}
+		}
+		if (best < EPS) return null;
+		if (pivot !== col) {
+			for (let k = 0; k < n; k++) {
+				const tmp = m[col * n + k];
+				m[col * n + k] = m[pivot * n + k];
+				m[pivot * n + k] = tmp;
+			}
+			const tmp = y[col];
+			y[col] = y[pivot];
+			y[pivot] = tmp;
+		}
+		const diag = m[col * n + col];
+		for (let row = col + 1; row < n; row++) {
+			const factor = m[row * n + col] / diag;
+			if (factor === 0) continue;
+			for (let k = col; k < n; k++) m[row * n + k] = m[row * n + k] - factor * m[col * n + k];
+			y[row] = y[row] - factor * y[col];
+		}
+	}
+	const x = new Array(n).fill(0);
+	for (let row = n - 1; row >= 0; row--) {
+		let sum = y[row];
+		for (let k = row + 1; k < n; k++) sum -= m[row * n + k] * x[k];
+		x[row] = sum / m[row * n + row];
+	}
+	return x.every(Number.isFinite) ? x : null;
+}
+/**
+* Estimate the exact planar homography H (row-major 3×3, h₃₃ = 1) mapping object
+* plane coords `(X,Y,1)` to NORMALIZED image coords `(x,y,1)` from 4 (or more)
+* correspondences via a DLT. Returns `null` when the configuration is degenerate
+* (collinear points → singular system). `objectXY`/`imageXY` are parallel arrays
+* of `[X,Y]` / `[x,y]`.
+*/
+function homographyFromCorrespondences(objectXY, imageXY) {
+	const n = objectXY.length;
+	if (n < 4 || imageXY.length !== n) return null;
+	const A = [];
+	const b = [];
+	for (let i = 0; i < 4; i++) {
+		const o = objectXY[i];
+		const im = imageXY[i];
+		const X = o[0];
+		const Y = o[1];
+		const x = im[0];
+		const y = im[1];
+		A.push(X, Y, 1, 0, 0, 0, -x * X, -x * Y);
+		b.push(x);
+		A.push(0, 0, 0, X, Y, 1, -y * X, -y * Y);
+		b.push(y);
+	}
+	const h = solveLinear(A, b);
+	if (!h) return null;
+	const H = [
+		h[0],
+		h[1],
+		h[2],
+		h[3],
+		h[4],
+		h[5],
+		h[6],
+		h[7],
+		1
+	];
+	return H.every(Number.isFinite) ? H : null;
+}
+/** Multiply two row-major 3×3 matrices: returns A·B. */
+function mul3(a, b) {
+	const out = new Array(9).fill(0);
+	for (let r = 0; r < 3; r++) for (let c = 0; c < 3; c++) out[r * 3 + c] = a[r * 3] * b[c] + a[r * 3 + 1] * b[3 + c] + a[r * 3 + 2] * b[6 + c];
+	return out;
+}
+/** Transpose a row-major 3×3 matrix. */
+function transpose3(m) {
+	return [
+		m[0],
+		m[3],
+		m[6],
+		m[1],
+		m[4],
+		m[7],
+		m[2],
+		m[5],
+		m[8]
+	];
+}
+/** Determinant of a row-major 3×3 matrix. */
+function det3(m) {
+	return m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);
+}
+/** Inverse-transpose of a row-major 3×3 matrix, or `null` if singular. */
+function invTranspose3(m) {
+	const d = det3(m);
+	if (Math.abs(d) < EPS) return null;
+	const inv = 1 / d;
+	const c00 = m[4] * m[8] - m[5] * m[7];
+	const c01 = -(m[3] * m[8] - m[5] * m[6]);
+	const c02 = m[3] * m[7] - m[4] * m[6];
+	const c10 = -(m[1] * m[8] - m[2] * m[7]);
+	const c11 = m[0] * m[8] - m[2] * m[6];
+	const c12 = -(m[0] * m[7] - m[1] * m[6]);
+	const c20 = m[1] * m[5] - m[2] * m[4];
+	const c21 = -(m[0] * m[5] - m[2] * m[3]);
+	const c22 = m[0] * m[4] - m[1] * m[3];
+	return [
+		c00 * inv,
+		c01 * inv,
+		c02 * inv,
+		c10 * inv,
+		c11 * inv,
+		c12 * inv,
+		c20 * inv,
+		c21 * inv,
+		c22 * inv
+	];
+}
+/**
+* Project a near-orthogonal 3×3 matrix onto the nearest rotation (SO(3)) by
+* iterative polar decomposition (Higham: `R_{k+1} = ½(R_k + R_k⁻ᵀ)`). Converges
+* quadratically for an already near-orthonormal input; needs no SVD/eigensolver
+* (gl-matrix has neither). Forces `det = +1` by flipping the least-aligned column
+* if the input was left-handed. Returns the input unchanged if it is singular.
+*/
+function nearestRotation3x3(input) {
+	let R = input;
+	for (let i = 0; i < 12; i++) {
+		const invT = invTranspose3(R);
+		if (!invT) break;
+		const next = [
+			.5 * (R[0] + invT[0]),
+			.5 * (R[1] + invT[1]),
+			.5 * (R[2] + invT[2]),
+			.5 * (R[3] + invT[3]),
+			.5 * (R[4] + invT[4]),
+			.5 * (R[5] + invT[5]),
+			.5 * (R[6] + invT[6]),
+			.5 * (R[7] + invT[7]),
+			.5 * (R[8] + invT[8])
+		];
+		let delta = 0;
+		for (let k = 0; k < 9; k++) delta += Math.abs(next[k] - R[k]);
+		R = next;
+		if (delta < 1e-15) break;
+	}
+	if (det3(R) < 0) R = [
+		R[0],
+		R[1],
+		-R[2],
+		R[3],
+		R[4],
+		-R[5],
+		R[6],
+		R[7],
+		-R[8]
+	];
+	return R;
+}
+/** Cross product a × b. */
+function cross(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+/**
+* Generate the planar-pose candidates from a homography via true IPPE
+* (Collins & Bartoli 2014). Returns up to 4 chirality-valid candidates (the two
+* tilt-flip roots × the z-sign of the in-plane axes); the caller picks the
+* lowest reprojection error. Returns `[]` when the homography is degenerate.
+*
+* Derivation (see planar-pnp.ts.md): with `[r1 r2]` the first two columns of R,
+* the local first-order map at the model origin gives `M·[r1 r2] = t_z·J` where
+* `M = [[1,0,-p],[0,1,-q]]`, `(p,q)` is the origin's normalized image and `J` the
+* 2×2 Jacobian of the homography there. Aligning the origin's ray to +z (rotation
+* `Rv`) reduces this to a 2×2 block `B = τ·g` whose unknown bottom row plus the
+* orthonormality of `[r1 r2]` yields a biquadratic in `τ = t_z`:
+* `D²·τ⁴ − S·τ² + 1 = 0`, with `S = ‖g‖_F²`, `D = det(g)`. Its two roots are the
+* two planar poses (they coincide fronto-parallel — no flip there).
+*/
+function ippePoseCandidates(H) {
+	const p = H[2];
+	const q = H[5];
+	const Jxx = H[0] - p * H[6];
+	const Jxy = H[1] - p * H[7];
+	const Jyx = H[3] - q * H[6];
+	const Jyy = H[4] - q * H[7];
+	const t = Math.hypot(p, q);
+	const s = Math.hypot(p, q, 1);
+	let Rv;
+	if (t < EPS) Rv = [
+		1,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		1
+	];
+	else {
+		const ax = q / t;
+		const ay = -p / t;
+		const c = 1 / s;
+		const sn = t / s;
+		const omc = 1 - c;
+		Rv = [
+			c + ax * ax * omc,
+			ax * ay * omc,
+			ay * sn,
+			ax * ay * omc,
+			c + ay * ay * omc,
+			-ax * sn,
+			-ay * sn,
+			ax * sn,
+			c
+		];
+	}
+	const RvT = transpose3(Rv);
+	const w = Rv[6] * p + Rv[7] * q + Rv[8];
+	if (Math.abs(w) < EPS) return [];
+	const g00 = (Rv[0] * Jxx + Rv[1] * Jyx) / w;
+	const g01 = (Rv[0] * Jxy + Rv[1] * Jyy) / w;
+	const g10 = (Rv[3] * Jxx + Rv[4] * Jyx) / w;
+	const g11 = (Rv[3] * Jxy + Rv[4] * Jyy) / w;
+	const G1 = g00 * g00 + g10 * g10;
+	const G2 = g01 * g01 + g11 * g11;
+	const G12 = g00 * g01 + g10 * g11;
+	const S = G1 + G2;
+	const D = g00 * g11 - g01 * g10;
+	const tauSquared = [];
+	if (Math.abs(D) < EPS) {
+		if (S > EPS) tauSquared.push(1 / S);
+	} else {
+		const disc = Math.max(0, S * S - 4 * D * D);
+		const root = Math.sqrt(disc);
+		const denom = 2 * D * D;
+		const t1 = (S + root) / denom;
+		const t2 = (S - root) / denom;
+		if (t1 > EPS) tauSquared.push(t1);
+		if (t2 > EPS && Math.abs(t2 - t1) > 1e-9 * t1) tauSquared.push(t2);
+	}
+	const candidates = [];
+	for (const tau2 of tauSquared) {
+		const tau = Math.sqrt(tau2);
+		const a2 = Math.max(0, 1 - tau2 * G1);
+		const b2 = Math.max(0, 1 - tau2 * G2);
+		const aMag = Math.sqrt(a2);
+		const bMag = Math.sqrt(b2);
+		const wantNeg = -tau2 * G12 < 0;
+		for (const signA of [1, -1]) {
+			const a = signA * aMag;
+			let b = bMag;
+			if (wantNeg) b = -b;
+			b *= signA;
+			const cand = buildCandidate(g00, g10, g01, g11, a, b, tau, Rv, RvT);
+			if (cand) candidates.push(cand);
+		}
+	}
+	return candidates;
+}
+/** Assemble a pose candidate from the aligned-frame 2×2 block + z-components. */
+function buildCandidate(g00, g10, g01, g11, a, b, tau, Rv, RvT) {
+	const r1 = [
+		tau * g00,
+		tau * g10,
+		a
+	];
+	const r2 = [
+		tau * g01,
+		tau * g11,
+		b
+	];
+	const r3 = cross(r1, r2);
+	const R = nearestRotation3x3(mul3(RvT, [
+		r1[0],
+		r2[0],
+		r3[0],
+		r1[1],
+		r2[1],
+		r3[1],
+		r1[2],
+		r2[2],
+		r3[2]
+	]));
+	const tt = [
+		tau * Rv[6],
+		tau * Rv[7],
+		tau * Rv[8]
+	];
+	if (!R.every(Number.isFinite) || !tt.every(Number.isFinite)) return null;
+	return {
+		R,
+		t: tt
+	};
+}
+/**
+* Convert a row-major rotation matrix to a Rodrigues vector (axis · angle).
+* Double-precision, no gl-matrix Float32 round-trip.
+*/
+function rotationToRodrigues(R) {
+	let cosTheta = (R[0] + R[4] + R[8] - 1) / 2;
+	cosTheta = Math.min(1, Math.max(-1, cosTheta));
+	const theta = Math.acos(cosTheta);
+	if (theta < 1e-9) return [
+		0,
+		0,
+		0
+	];
+	if (Math.PI - theta < 1e-6) {
+		const xx = (R[0] + 1) / 2;
+		const yy = (R[4] + 1) / 2;
+		const zz = (R[8] + 1) / 2;
+		let ax = Math.sqrt(Math.max(0, xx));
+		let ay = Math.sqrt(Math.max(0, yy));
+		let az = Math.sqrt(Math.max(0, zz));
+		if (ax >= ay && ax >= az) {
+			ay = Math.sign(R[1] + R[3]) * ay;
+			az = Math.sign(R[2] + R[6]) * az;
+		} else if (ay >= az) {
+			ax = Math.sign(R[1] + R[3]) * ax;
+			az = Math.sign(R[5] + R[7]) * az;
+		} else {
+			ax = Math.sign(R[2] + R[6]) * ax;
+			ay = Math.sign(R[5] + R[7]) * ay;
+		}
+		const norm = Math.hypot(ax, ay, az) || 1;
+		return [
+			theta * ax / norm,
+			theta * ay / norm,
+			theta * az / norm
+		];
+	}
+	const k = theta / (2 * Math.sin(theta));
+	return [
+		k * (R[7] - R[5]),
+		k * (R[2] - R[6]),
+		k * (R[3] - R[1])
+	];
+}
+/** RMS reprojection error (px) of a candidate against the detected corners. */
+function reprojectionError(cand, objectPoints, imagePoints, intr) {
+	const { R, t } = cand;
+	let sumSq = 0;
+	for (let i = 0; i < objectPoints.length; i++) {
+		const o = objectPoints[i];
+		const img = imagePoints[i];
+		const cx = R[0] * o[0] + R[1] * o[1] + R[2] * o[2] + t[0];
+		const cy = R[3] * o[0] + R[4] * o[1] + R[5] * o[2] + t[1];
+		const cz = R[6] * o[0] + R[7] * o[1] + R[8] * o[2] + t[2];
+		if (!(cz > 0)) return Infinity;
+		const px = intr.cx + intr.fx * cx / cz;
+		const py = intr.cy + intr.fy * cy / cz;
+		const dx = px - img.x;
+		const dy = py - img.y;
+		sumSq += dx * dx + dy * dy;
+	}
+	return Math.sqrt(sumSq / objectPoints.length);
+}
+/**
+* `SolvePnpSquare` for a centered planar square via pure-JS IPPE. Stateless and
+* synchronous — construct once and reuse, or construct per call; either is fine.
+*/
+var PlanarPnpSquare = class {
+	solve(objectPoints, imagePoints, intrinsics) {
+		if (objectPoints.length !== imagePoints.length || objectPoints.length < 4) return null;
+		const { fx, fy, cx, cy } = intrinsics;
+		if (!(fx > 0) || !(fy > 0) || !Number.isFinite(cx) || !Number.isFinite(cy)) return null;
+		const objectXY = [];
+		const imageXY = [];
+		for (let i = 0; i < objectPoints.length; i++) {
+			const o = objectPoints[i];
+			const im = imagePoints[i];
+			if (!Number.isFinite(im.x) || !Number.isFinite(im.y)) return null;
+			objectXY.push([o[0], o[1]]);
+			imageXY.push([(im.x - cx) / fx, (im.y - cy) / fy]);
+		}
+		const H = homographyFromCorrespondences(objectXY, imageXY);
+		if (!H) return null;
+		const candidates = ippePoseCandidates(H);
+		if (candidates.length === 0) return null;
+		let best = null;
+		let bestErr = Infinity;
+		for (const cand of candidates) {
+			const err = reprojectionError(cand, objectPoints, imagePoints, intrinsics);
+			if (err < bestErr) {
+				bestErr = err;
+				best = cand;
+			}
+		}
+		if (!best || !Number.isFinite(bestErr)) return null;
+		const rvec = rotationToRodrigues(best.R);
+		const tvec = best.t;
+		if (![...rvec, ...tvec].every(Number.isFinite) || !(tvec[2] > 0)) return null;
+		return {
+			rvec,
+			tvec
+		};
+	}
+};
+//#endregion
+export { PlanarPnpSquare, homographyFromCorrespondences, ippePoseCandidates, nearestRotation3x3, rotationToRodrigues, solveLinear };

package/dist/ar/qr-debug-view.d.ts

@@ -0,0 +1,2 @@
+import { n as createQrDebugView, t as QrDebugView } from "../qr-debug-view-Brl73HGO.js";
+export { QrDebugView, createQrDebugView };

package/dist/ar/qr-debug-view.js

@@ -0,0 +1,89 @@
+import { WEBXR_TO_NUE } from "./webxr-nue-basis.js";
+import { AxesHelper, BoxGeometry, Group, Mesh, MeshBasicMaterial } from "three";
+//#region ../src/ar/qr-debug-view.ts
+/**
+* QR debug view — the shared 3D "is it glued to the code?" overlay: a 3D axis at
+* the solved QR pose plus a semi-transparent cube sized to the QR so its front
+* face lands on the printed corners. Both are parented under `arWorldGroup` so
+* they ride the alignment / transform chain exactly like real content.
+*
+* Promoted to the framework (recorder live-QR WS-5) as the **shared consumer**
+* view: both the QR-tracking demo and the GPS Recorder render this same overlay
+* off the derived pose (`qr-derived-pose.ts` / `selectSolvedQrPose`). The view is
+* pure three.js — it knows nothing about who solved the pose, so it runs
+* identically live and on replay.
+*
+* Persistence across detection misses: `update()` is called on every lock;
+* `clear()` is NOT called on a miss, so the objects keep their last pose and
+* never flicker between throttled detections. They stay hidden until the first
+* `update()`.
+*
+* Coordinate space (IMPORTANT): the QR pose is in **raw WebXR** space (the
+* corners are depth-unprojected with the raw WebXR camera pose), but the
+* injected `parent` (`arWorldGroup`) local space is **NUE**. So the objects must
+* ride the SAME {@link WEBXR_TO_NUE} basis the camera does (`arWorldGroup →
+* basisChangeNode → arpose → camera`). We mirror that by hanging them off an
+* internal basis node carrying `WEBXR_TO_NUE`; parenting them directly under
+* `arWorldGroup` would leave them East/North axis-swapped and they would NOT
+* line up with the camera/QR on a real device (the recurring scene-frame bug —
+* see the frame-tile / occupancy-cube / hit-test-reticle precedents). We never
+* touch the camera; WebXR owns its pose.
+*
+* @see qr-derived-pose.ts — derives the `Pose` this view renders (size + PnP).
+* @see webxr-nue-basis.ts — the `WEBXR_TO_NUE` basis the objects ride.
+*/
+/** A thin slab so the cube's front face sits on the printed code (1 cm deep). */
+const CUBE_DEPTH_M = .01;
+/**
+* Create the debug axis + cube under `parent` (the `arWorldGroup`). Objects
+* start hidden; the first `update()` reveals and positions them.
+*/
+function createQrDebugView(parent) {
+	const basis = new Group();
+	basis.name = "qr-debug-basis";
+	basis.matrix.copy(WEBXR_TO_NUE);
+	basis.matrixAutoUpdate = false;
+	parent.add(basis);
+	const axes = new AxesHelper(.15);
+	axes.visible = false;
+	const cubeMaterial = new MeshBasicMaterial({
+		color: 3399167,
+		transparent: true,
+		opacity: .35,
+		depthWrite: false
+	});
+	const cube = new Mesh(new BoxGeometry(1, 1, 1), cubeMaterial);
+	cube.visible = false;
+	basis.add(axes);
+	basis.add(cube);
+	function applyPose(object, pose) {
+		object.position.set(pose.position[0], pose.position[1], pose.position[2]);
+		object.quaternion.set(pose.rotation[0], pose.rotation[1], pose.rotation[2], pose.rotation[3]);
+	}
+	return {
+		update(pose, sizeM) {
+			applyPose(axes, pose);
+			axes.visible = true;
+			if (sizeM === null) {
+				cube.visible = false;
+				return;
+			}
+			applyPose(cube, pose);
+			cube.scale.set(sizeM, sizeM, CUBE_DEPTH_M);
+			cube.translateZ(-CUBE_DEPTH_M / 2);
+			cube.visible = true;
+		},
+		clear() {
+			axes.visible = false;
+			cube.visible = false;
+		},
+		dispose() {
+			parent.remove(basis);
+			axes.dispose();
+			cube.geometry.dispose();
+			cubeMaterial.dispose();
+		}
+	};
+}
+//#endregion
+export { createQrDebugView };

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

@@ -0,0 +1,2 @@
+import { a as createIncrementalQrPlacement, c as deriveSolvedQrPose, i as RawQrObservation, l as solveQrPoseFromObservation, n as DerivedQrPlacement, o as deriveQrPlacement, r as IncrementalQrPlacement, s as deriveQrSizeM, t as DeriveQrPoseDeps } from "../qr-derived-pose-CmxTP2m4.js";
+export { DeriveQrPoseDeps, DerivedQrPlacement, IncrementalQrPlacement, RawQrObservation, createIncrementalQrPlacement, deriveQrPlacement, deriveQrSizeM, deriveSolvedQrPose, solveQrPoseFromObservation };

package/dist/ar/qr-derived-pose.js

@@ -0,0 +1,114 @@
+import { t as createQrSizeMeasurer } from "../qr-size-measurer-DLb33geH.js";
+import { intrinsicsFromProjection, solveQrPose } from "./qr-pose.js";
+//#region ../src/ar/qr-derived-pose.ts
+/**
+* Replay a marker's observation history through a fresh size measurer (each
+* observation sized against its own as-of depth context) and return the running
+* median size in meters, or `null` if no observation could be sized yet.
+*
+* Re-runs the whole history per call — O(history), bounded by the slice ring
+* buffer. Cheap for v1; memoize if the debug-viz cadence makes it hot.
+*/
+function deriveQrSizeM(text, observations, resolveDepthAt, sizeOptions) {
+	if (observations.length === 0) return null;
+	const measurer = createQrSizeMeasurer(sizeOptions);
+	for (const o of observations) {
+		const ctx = resolveDepthAt(o.timestamp);
+		if (!ctx) continue;
+		measurer.measure(text, o.corners, {
+			width: o.imageWidth,
+			height: o.imageHeight
+		}, ctx);
+	}
+	return measurer.current(text).estimateM;
+}
+/**
+* Solve the world pose of ONE raw observation given a known metric size. Pure
+* (no depth): intrinsics come from the observation's projection + frame size,
+* the corners + camera pose are recorded. Returns `null` when PnP rejects the
+* quad or exceeds the reprojection gate.
+*/
+function solveQrPoseFromObservation(observation, sizeM, solver, maxReprojectionErrorPx) {
+	const intrinsics = intrinsicsFromProjection(observation.projectionMatrix, observation.imageWidth, observation.imageHeight);
+	const solution = solveQrPose({
+		imagePoints: observation.corners,
+		sizeM,
+		intrinsics,
+		cameraPose: observation.cameraPose,
+		solver,
+		...maxReprojectionErrorPx !== void 0 ? { maxReprojectionErrorPx } : {}
+	});
+	return solution ? solution.qrPoseWorld : null;
+}
+/**
+* Derive the best-effort {@link DerivedQrPlacement} for a marker: accumulate the
+* size across the whole observation history (each against its as-of depth), then
+* solve the LATEST observation with that size — returning BOTH the pose and the
+* size (the debug cube needs the size; deriving once avoids two history passes).
+* Returns `null` when there is no history, no observation can be sized, or PnP
+* rejects the latest quad — callers render nothing (best-effort viz) rather than
+* throwing.
+*/
+function deriveQrPlacement(text, observations, deps) {
+	if (observations.length === 0) return null;
+	const sizeM = deriveQrSizeM(text, observations, deps.resolveDepthAt, deps.sizeOptions);
+	if (sizeM === null) return null;
+	const latest = observations[observations.length - 1];
+	const pose = solveQrPoseFromObservation(latest, sizeM, deps.solver, deps.maxReprojectionErrorPx);
+	return pose ? {
+		pose,
+		sizeM
+	} : null;
+}
+/**
+* Derive only the best-effort solved WORLD pose for a marker (the size is an
+* internal of {@link deriveQrPlacement}). Returns `null` under the same
+* conditions. Kept for callers that need the pose alone.
+*/
+function deriveSolvedQrPose(text, observations, deps) {
+	return deriveQrPlacement(text, observations, deps)?.pose ?? null;
+}
+function createIncrementalQrPlacement(deps) {
+	const measurer = createQrSizeMeasurer(deps.sizeOptions);
+	const lastFoldedTs = /* @__PURE__ */ new Map();
+	const lastPlacement = /* @__PURE__ */ new Map();
+	return {
+		update(text, observations) {
+			if (observations.length === 0) return null;
+			const newestTs = observations[observations.length - 1].timestamp;
+			const foldedTs = lastFoldedTs.get(text) ?? -Infinity;
+			if (newestTs <= foldedTs) return lastPlacement.get(text) ?? null;
+			let maxFoldedTs = foldedTs;
+			for (const o of observations) {
+				if (o.timestamp <= foldedTs) continue;
+				const ctx = deps.resolveDepthAt(o.timestamp);
+				if (!ctx) continue;
+				measurer.measure(text, o.corners, {
+					width: o.imageWidth,
+					height: o.imageHeight
+				}, ctx);
+				maxFoldedTs = o.timestamp;
+			}
+			lastFoldedTs.set(text, maxFoldedTs);
+			const sizeM = measurer.current(text).estimateM;
+			let placement = null;
+			if (sizeM !== null) {
+				const latest = observations[observations.length - 1];
+				const pose = solveQrPoseFromObservation(latest, sizeM, deps.solver, deps.maxReprojectionErrorPx);
+				placement = pose ? {
+					pose,
+					sizeM
+				} : null;
+			}
+			lastPlacement.set(text, placement);
+			return placement;
+		},
+		reset(text) {
+			lastFoldedTs.delete(text);
+			lastPlacement.delete(text);
+			measurer.reset(text);
+		}
+	};
+}
+//#endregion
+export { createIncrementalQrPlacement, deriveQrPlacement, deriveQrSizeM, deriveSolvedQrPose, solveQrPoseFromObservation };

package/dist/ar/qr-detection-controller.d.ts

@@ -0,0 +1,2 @@
+import { a as createQrDetectionController, i as RawObservationSink, n as QrDetectionControllerDeps, r as QrScanStatus, t as QrDetectionController } from "../qr-detection-controller-CDurHv8E.js";
+export { QrDetectionController, QrDetectionControllerDeps, QrScanStatus, RawObservationSink, createQrDetectionController };

package/dist/ar/qr-detection-controller.js

@@ -0,0 +1,2 @@
+import { t as createQrDetectionController } from "../qr-detection-controller-B-tLVd-S.js";
+export { createQrDetectionController };

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

@@ -0,0 +1,2 @@
+import { a as QrFrontEnd, c as createBarcodeDetectorFrontEnd, i as QrDetection, n as BarcodeDetectorLike, o as RgbaImage, r as DetectedBarcodeLike, s as ToImageBitmapSource, t as BarcodeDetectorFrontEnd } from "../qr-frontend--fFX25mV.js";
+export { BarcodeDetectorFrontEnd, BarcodeDetectorLike, DetectedBarcodeLike, QrDetection, QrFrontEnd, RgbaImage, ToImageBitmapSource, createBarcodeDetectorFrontEnd };

package/dist/ar/qr-frontend.js

@@ -0,0 +1,60 @@
+//#region ../src/ar/qr-frontend.ts
+const defaultToImageData = (image) => new ImageData(new Uint8ClampedArray(image.data), image.width, image.height);
+var BarcodeDetectorFrontEnd = class {
+	kind = "barcode-detector";
+	detector;
+	toSource;
+	constructor(detector, toSource = defaultToImageData) {
+		this.detector = detector;
+		this.toSource = toSource;
+	}
+	async detect(image) {
+		const results = await this.detector.detect(this.toSource(image));
+		for (const r of results) {
+			const corners = toQuad(r.cornerPoints);
+			if (corners && typeof r.rawValue === "string" && r.rawValue.length > 0) return {
+				corners,
+				text: r.rawValue
+			};
+		}
+		return null;
+	}
+};
+/**
+* Build a {@link BarcodeDetectorFrontEnd} if the runtime exposes a
+* `BarcodeDetector` constructor; otherwise `null` (→ the caller must handle the
+* unsupported-browser case; there is no OpenCV fallback). `ctor` is injectable
+* for tests.
+*/
+function createBarcodeDetectorFrontEnd(ctor) {
+	const Ctor = ctor ?? globalThis.BarcodeDetector;
+	if (!Ctor) return null;
+	return new BarcodeDetectorFrontEnd(new Ctor({ formats: ["qr_code"] }));
+}
+function toQuad(points) {
+	if (points.length !== 4) return null;
+	const [a, b, c, d] = points;
+	if (!a || !b || !c || !d) return null;
+	const out = [
+		{
+			x: a.x,
+			y: a.y
+		},
+		{
+			x: b.x,
+			y: b.y
+		},
+		{
+			x: c.x,
+			y: c.y
+		},
+		{
+			x: d.x,
+			y: d.y
+		}
+	];
+	if (out.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y))) return null;
+	return out;
+}
+//#endregion
+export { BarcodeDetectorFrontEnd, createBarcodeDetectorFrontEnd };