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

package/dist/ar/occupancy-mesher.js

@@ -0,0 +1,638 @@
+import { a as packCellKey } from "../cell-key-DIB4rOTV.js";
+//#region ../src/ar/occupancy-mesher.ts
+/** Resolve the effective mesher mode from the (possibly legacy) options. */
+function resolveMode(options) {
+	if (options?.mode) return options.mode;
+	return options?.greedy ? "greedy" : "per-face";
+}
+/**
+* Right-handed cyclic axis assignment per face-normal axis `d`: `(d, u, v)`
+* with `eu × ev = ed`, so a `(uMin,vMin)→(uMax,vMin)→(uMax,vMax)→(uMin,vMax)`
+* quad has the `+d` outward normal (and the reverse order has `−d`). Used by the
+* greedy mesher to keep merged-quad winding consistent with the per-face path.
+*/
+const GREEDY_DIRS = [
+	{
+		d: 0,
+		u: 1,
+		v: 2
+	},
+	{
+		d: 1,
+		u: 2,
+		v: 0
+	},
+	{
+		d: 2,
+		u: 0,
+		v: 1
+	}
+];
+/**
+* The six cube faces with outward (CCW-from-outside) winding. Corner signs are
+* ±1 multipliers of the half-cell extent. Triangulated as (0,1,2)+(0,2,3).
+*/
+const FACES = [
+	{
+		neighbour: [
+			1,
+			0,
+			0
+		],
+		corners: [
+			[
+				1,
+				-1,
+				-1
+			],
+			[
+				1,
+				1,
+				-1
+			],
+			[
+				1,
+				1,
+				1
+			],
+			[
+				1,
+				-1,
+				1
+			]
+		]
+	},
+	{
+		neighbour: [
+			-1,
+			0,
+			0
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				-1
+			],
+			[
+				-1,
+				-1,
+				1
+			],
+			[
+				-1,
+				1,
+				1
+			],
+			[
+				-1,
+				1,
+				-1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			1,
+			0
+		],
+		corners: [
+			[
+				-1,
+				1,
+				-1
+			],
+			[
+				-1,
+				1,
+				1
+			],
+			[
+				1,
+				1,
+				1
+			],
+			[
+				1,
+				1,
+				-1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			-1,
+			0
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				-1
+			],
+			[
+				1,
+				-1,
+				-1
+			],
+			[
+				1,
+				-1,
+				1
+			],
+			[
+				-1,
+				-1,
+				1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			0,
+			1
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				1
+			],
+			[
+				1,
+				-1,
+				1
+			],
+			[
+				1,
+				1,
+				1
+			],
+			[
+				-1,
+				1,
+				1
+			]
+		]
+	},
+	{
+		neighbour: [
+			0,
+			0,
+			-1
+		],
+		corners: [
+			[
+				-1,
+				-1,
+				-1
+			],
+			[
+				-1,
+				1,
+				-1
+			],
+			[
+				1,
+				1,
+				-1
+			],
+			[
+				1,
+				-1,
+				-1
+			]
+		]
+	}
+];
+/** Finite, integer, and within the packable key range on every axis.
+*  `Number.isInteger` subsumes the finiteness check (NaN/±Infinity are not
+*  integers) and rejects fractional coordinates, which the packed-key algebra
+*  cannot key safely (neighbour ±1 and half-lattice `2·coord ± 1` keys only
+*  coincide for integer cells). */
+function isPackableCell(cell) {
+	for (let i = 0; i < 3; i++) {
+		const c = cell[i];
+		if (!Number.isInteger(c) || Math.abs(c) > 32767) return false;
+	}
+	return true;
+}
+/** True iff all three components are finite. A non-finite measured centroid
+*  from `getCellPoint` (an upstream tracking/accumulation glitch) must degrade
+*  to the geometric fallback exactly like a `null` one — otherwise it poisons
+*  every welded vertex / shared corner that averages it, and it also breaks
+*  `runMeshRequest`'s byte-identical parity with a direct mesh (the worker wire
+*  protocol packs "no centroid" as NaN, so NaN already falls back off-thread). */
+function isFiniteVector3(v) {
+	return Number.isFinite(v[0]) && Number.isFinite(v[1]) && Number.isFinite(v[2]);
+}
+/**
+* Mesh a snapshot of occupied cells into a face-culled surface + AABB list.
+*
+* Only faces whose neighbour cell is **not** in the occupied set are emitted
+* (interior faces are dropped), so the triangle count scales with the surface
+* area of the occupied set. Duplicate cells in `cells` are de-duplicated;
+* cells with a non-finite or non-integer coordinate are skipped defensively (a
+* tracking glitch upstream must not poison the mesh, and the packed cell keys
+* are only collision-safe for integer coordinates).
+*
+* @param cells     occupied cells (e.g. `grid.getOccupiedCells(minConfidence)`).
+* @param cellSizeM cube edge length in metres (must be a positive finite number).
+* @returns positions/indices (raw-WebXR metres) + one AABB per unique cell.
+*/
+function meshOccupiedCells(cells, cellSizeM, options) {
+	if (!Number.isFinite(cellSizeM) || cellSizeM <= 0) throw new RangeError(`cellSizeM must be a positive number, got ${cellSizeM}`);
+	const half = cellSizeM / 2;
+	const occupied = /* @__PURE__ */ new Set();
+	const uniqueCells = [];
+	for (const cell of cells) {
+		if (!isPackableCell(cell)) continue;
+		const key = packCellKey(cell[0], cell[1], cell[2]);
+		if (occupied.has(key)) continue;
+		occupied.add(key);
+		uniqueCells.push(cell);
+	}
+	const sharedHalfExtents = Object.freeze([
+		half,
+		half,
+		half
+	]);
+	const aabbs = uniqueCells.map(([x, y, z]) => ({
+		center: [
+			x * cellSizeM,
+			y * cellSizeM,
+			z * cellSizeM
+		],
+		halfExtents: sharedHalfExtents
+	}));
+	const positions = [];
+	const indices = [];
+	const mode = resolveMode(options);
+	if (mode === "greedy") buildGreedy(occupied, uniqueCells, cellSizeM, positions, indices);
+	else if (mode === "smooth") buildSmooth(occupied, uniqueCells, cellSizeM, options?.getCellPoint, positions, indices);
+	else if (mode === "corner-fit") buildCornerFit(occupied, uniqueCells, cellSizeM, options?.getCellPoint, positions, indices);
+	else buildCulled(occupied, uniqueCells, cellSizeM, positions, indices);
+	return {
+		positions: new Float32Array(positions),
+		indices: new Uint32Array(indices),
+		aabbs
+	};
+}
+/** Push a quad (4 corners, already ordered) as two triangles. */
+/** Per-face culling: emit each exposed unit face as its own quad. */
+function buildCulled(occupied, uniqueCells, cellSizeM, positions, indices) {
+	const half = cellSizeM / 2;
+	for (const [x, y, z] of uniqueCells) {
+		const cx = x * cellSizeM;
+		const cy = y * cellSizeM;
+		const cz = z * cellSizeM;
+		for (const face of FACES) {
+			const nx = x + face.neighbour[0];
+			const ny = y + face.neighbour[1];
+			const nz = z + face.neighbour[2];
+			if (occupied.has(packCellKey(nx, ny, nz))) continue;
+			const base = positions.length / 3;
+			const corners = face.corners;
+			for (let i = 0; i < 4; i++) {
+				const c = corners[i];
+				positions.push(cx + c[0] * half, cy + c[1] * half, cz + c[2] * half);
+			}
+			indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+		}
+	}
+}
+/**
+* 'smooth' mode — **standard Naive Surface Nets (dual contouring)** over the
+* occupancy field, consuming the per-cell measured centroids the cube meshers
+* discard.
+*
+* Treats occupancy as a binary field sampled at integer cell coordinates and
+* contours the occupied/empty boundary:
+*  - **Vertices** — one welded vertex per "dual cell" (a unit cube whose 8
+*    corners are the cells `b … b+1`) that **straddles** the boundary (≥1
+*    occupied AND ≥1 empty corner), placed at the **mean of its occupied
+*    corners' `getCellPoint()`** (the measured surface points; the corners'
+*    geometric centres without a provider). Welding by dual-cell key makes the
+*    surface crack-free.
+*  - **Quads** — one per occupied↔empty **crossing**: for every occupied-cell
+*    face whose neighbour is empty (the SAME set the cube mesher emits), a quad
+*    joins the 4 dual cells sharing that edge, wound to face the empty side.
+*
+* Because there is one quad per crossing, **coverage matches the cubes** — unlike
+* the previous 2×2-fully-occupied-patch heuristic, which only meshed flat solid
+* blocks and so missed 80–90 % of a real, ragged depth surface (the reported
+* "barely any surfaces" bug; 2026-06-30 rewrite). The result is smooth (welded
+* vertices pulled onto the measured surface) and watertight for closed regions;
+* over a thin feature (a one-cell floor) the top and bottom dual vertices average
+* the same cells and coincide, so it reads as a single smooth sheet — the
+* smoothest of the modes. Exception: a dual cell with exactly ONE occupied
+* corner is nudged toward its dual-cell centre ({@link SINGLE_CORNER_NUDGE_K}),
+* so features thin in ≥2 dimensions (isolated voxels, line/pillar ends) keep a
+* non-zero area instead of collapsing onto a single point; on a thin floor this
+* puffs only the perimeter-corner vertices by ±0.25·cell.
+*/
+/**
+* 'smooth' single-occupied-corner fallback strength: a dual cell with exactly
+* one occupied corner places its vertex ON that corner's cell point, so every
+* dual cell around a feature thin in ≥2 dimensions (an isolated voxel, the end
+* of a 1-cell line/pillar) coincided with its neighbours → all-degenerate
+* (zero-area) triangles → thin features were invisible to the occluder despite
+* a full per-face triangle count. Nudging the `n === 1` vertex toward the
+* dual-cell centre by this fraction of the corner→centre distance (0.5 ⇒
+* ±0.25·cell per axis) keeps it a pure function of the dual cell, so welding /
+* watertightness and the measured-offset invariant are preserved. Trade-off
+* (accepted 2026-07-02): the `n === 1` perimeter corners of a thin floor (and
+* of a solid box) puff by ±0.25·cell — imperceptible for AR occlusion. Known
+* residual: the `n === 2` shaft rings of a long 1×1×N feature still collapse
+* (locally indistinguishable from a thin floor's intentionally-flat edges).
+* 0.25 was rejected as too close to imperceptibly-non-zero; 1.0 discards the
+* measured centroid exactly where data is sparsest. See
+* 2026-07-01-followup-smooth-mesher-single-corner-degeneracy.md.
+*/
+const SINGLE_CORNER_NUDGE_K = .5;
+function buildSmooth(occupied, uniqueCells, cellSizeM, getCellPoint, positions, indices) {
+	const pointCache = /* @__PURE__ */ new Map();
+	const scratch = [
+		0,
+		0,
+		0
+	];
+	const cellPoint = (ckey, x, y, z) => {
+		const hit = pointCache.get(ckey);
+		if (hit !== void 0) return hit;
+		let p = [
+			x * cellSizeM,
+			y * cellSizeM,
+			z * cellSizeM
+		];
+		if (getCellPoint) {
+			scratch[0] = x;
+			scratch[1] = y;
+			scratch[2] = z;
+			const cp = getCellPoint(scratch);
+			if (cp && isFiniteVector3(cp)) p = [
+				cp[0],
+				cp[1],
+				cp[2]
+			];
+		}
+		pointCache.set(ckey, p);
+		return p;
+	};
+	const vertexIndex = /* @__PURE__ */ new Map();
+	const dualVertex = (bx, by, bz) => {
+		const dkey = packCellKey(bx, by, bz);
+		const existing = vertexIndex.get(dkey);
+		if (existing !== void 0) return existing;
+		let sx = 0;
+		let sy = 0;
+		let sz = 0;
+		let n = 0;
+		let odx = 0;
+		let ody = 0;
+		let odz = 0;
+		for (let dx = 0; dx <= 1; dx++) for (let dy = 0; dy <= 1; dy++) for (let dz = 0; dz <= 1; dz++) {
+			const cx = bx + dx;
+			const cy = by + dy;
+			const cz = bz + dz;
+			const ckey = packCellKey(cx, cy, cz);
+			if (!occupied.has(ckey)) continue;
+			const p = cellPoint(ckey, cx, cy, cz);
+			sx += p[0];
+			sy += p[1];
+			sz += p[2];
+			n += 1;
+			odx = dx;
+			ody = dy;
+			odz = dz;
+		}
+		let px = sx / n;
+		let py = sy / n;
+		let pz = sz / n;
+		if (n === 1) {
+			const nudge = cellSizeM * SINGLE_CORNER_NUDGE_K;
+			px += (.5 - odx) * nudge;
+			py += (.5 - ody) * nudge;
+			pz += (.5 - odz) * nudge;
+		}
+		const idx = positions.length / 3;
+		positions.push(px, py, pz);
+		vertexIndex.set(dkey, idx);
+		return idx;
+	};
+	const dualBase = [
+		0,
+		0,
+		0
+	];
+	const c = [
+		0,
+		0,
+		0
+	];
+	for (const cell of uniqueCells) {
+		c[0] = cell[0];
+		c[1] = cell[1];
+		c[2] = cell[2];
+		for (const { d, u, v } of GREEDY_DIRS) for (let sgn = 1; sgn >= -1; sgn -= 2) {
+			dualBase[d] = c[d] + sgn;
+			dualBase[u] = c[u];
+			dualBase[v] = c[v];
+			if (occupied.has(packCellKey(dualBase[0], dualBase[1], dualBase[2]))) continue;
+			const baseD = sgn > 0 ? c[d] : c[d] - 1;
+			const bu0 = c[u] - 1;
+			const bv0 = c[v] - 1;
+			dualBase[d] = baseD;
+			dualBase[u] = bu0;
+			dualBase[v] = bv0;
+			const iA = dualVertex(dualBase[0], dualBase[1], dualBase[2]);
+			dualBase[u] = bu0 + 1;
+			const iB = dualVertex(dualBase[0], dualBase[1], dualBase[2]);
+			dualBase[v] = bv0 + 1;
+			const iC = dualVertex(dualBase[0], dualBase[1], dualBase[2]);
+			dualBase[u] = bu0;
+			const iD = dualVertex(dualBase[0], dualBase[1], dualBase[2]);
+			if (sgn > 0) indices.push(iA, iB, iC, iA, iC, iD);
+			else indices.push(iA, iD, iC, iA, iC, iB);
+		}
+	}
+}
+/**
+* 'corner-fit' mode — the per-face cube mesher with **displaced shared corners**.
+*
+* Keeps {@link buildCulled}'s exact face topology (same exposed faces), but each
+* lattice corner — identified by its integer half-lattice key `(2x±1, 2y±1,
+* 2z±1)` so every cell sharing it produces the SAME key — is **nudged by the mean
+* sub-cell offset** (`getCellPoint() − cellCentre`) of the occupied cells
+* touching it. Vertices are welded by corner key, so adjacent faces reference the
+* identical displaced position: seams stay coincident ⇒ the surface deforms to
+* hug the measured points yet stays **watertight** (the even-edge-cover invariant
+* `'smooth'` gives up). Without a `getCellPoint` provider every corner falls back
+* to the geometric corner `key · cellSize/2`, i.e. plain cubes.
+*
+* Why the **offset**, not the absolute centroid mean (2026-06-30 fix): moving a
+* corner onto the absolute mean collapsed thin features — a one-cell-thick floor's
+* top and bottom corners average the SAME cells, so they coincided into a flat
+* sheet visually indistinguishable from `'smooth'`. Adding the offset to each
+* corner's OWN geometric position keeps the cube's thickness, so `'corner-fit'`
+* stays a distinct, cube-like, watertight option.
+*
+* Tradeoffs vs `'smooth'`: watertight and exact-cube topology, but corners are
+* 8-way averages (so geometry only *approaches* the measured points, never lands
+* on them) and the per-face O(surface-area) triangle cost is unchanged. Greedy
+* merging does not apply (displaced corners are non-coplanar).
+*/
+function buildCornerFit(occupied, uniqueCells, cellSizeM, getCellPoint, positions, indices) {
+	const half = cellSizeM / 2;
+	const cornerSum = /* @__PURE__ */ new Map();
+	const addCornerOffset = (key, ox, oy, oz) => {
+		let acc = cornerSum.get(key);
+		if (!acc) {
+			acc = {
+				x: 0,
+				y: 0,
+				z: 0,
+				n: 0
+			};
+			cornerSum.set(key, acc);
+		}
+		acc.x += ox;
+		acc.y += oy;
+		acc.z += oz;
+		acc.n += 1;
+	};
+	for (const cell of uniqueCells) {
+		const cp = getCellPoint ? getCellPoint(cell) : null;
+		if (!cp || !isFiniteVector3(cp)) continue;
+		const ox = cp[0] - cell[0] * cellSizeM;
+		const oy = cp[1] - cell[1] * cellSizeM;
+		const oz = cp[2] - cell[2] * cellSizeM;
+		for (let sx = -1; sx <= 1; sx += 2) for (let sy = -1; sy <= 1; sy += 2) for (let sz = -1; sz <= 1; sz += 2) addCornerOffset(packCellKey(2 * cell[0] + sx, 2 * cell[1] + sy, 2 * cell[2] + sz), ox, oy, oz);
+	}
+	const vertexIndex = /* @__PURE__ */ new Map();
+	const cornerVertex = (kx, ky, kz) => {
+		const key = packCellKey(kx, ky, kz);
+		const existing = vertexIndex.get(key);
+		if (existing !== void 0) return existing;
+		const acc = cornerSum.get(key);
+		const px = kx * half + (acc ? acc.x / acc.n : 0);
+		const py = ky * half + (acc ? acc.y / acc.n : 0);
+		const pz = kz * half + (acc ? acc.z / acc.n : 0);
+		const idx = positions.length / 3;
+		positions.push(px, py, pz);
+		vertexIndex.set(key, idx);
+		return idx;
+	};
+	for (const [x, y, z] of uniqueCells) for (const face of FACES) {
+		const nx = x + face.neighbour[0];
+		const ny = y + face.neighbour[1];
+		const nz = z + face.neighbour[2];
+		if (occupied.has(packCellKey(nx, ny, nz))) continue;
+		const corners = face.corners;
+		const x2 = 2 * x;
+		const y2 = 2 * y;
+		const z2 = 2 * z;
+		const c0 = corners[0];
+		const c1 = corners[1];
+		const c2 = corners[2];
+		const c3 = corners[3];
+		const v0 = cornerVertex(x2 + c0[0], y2 + c0[1], z2 + c0[2]);
+		const v1 = cornerVertex(x2 + c1[0], y2 + c1[1], z2 + c1[2]);
+		const v2 = cornerVertex(x2 + c2[0], y2 + c2[1], z2 + c2[2]);
+		const v3 = cornerVertex(x2 + c3[0], y2 + c3[1], z2 + c3[2]);
+		indices.push(v0, v1, v2, v0, v2, v3);
+	}
+}
+/**
+* Greedy meshing: for each face-normal axis and side, sweep slices and merge
+* adjacent coplanar exposed faces into maximal rectangles, emitting one quad
+* per rectangle. The covered unit faces are identical to {@link buildCulled};
+* only the triangle count drops.
+*/
+function buildGreedy(occupied, uniqueCells, cellSizeM, positions, indices) {
+	const half = cellSizeM / 2;
+	const neighbour = [
+		0,
+		0,
+		0
+	];
+	for (const { d, u, v } of GREEDY_DIRS) for (let sign = 1; sign >= -1; sign -= 2) {
+		const slices = /* @__PURE__ */ new Map();
+		for (const cell of uniqueCells) {
+			neighbour[0] = cell[0];
+			neighbour[1] = cell[1];
+			neighbour[2] = cell[2];
+			neighbour[d] += sign;
+			if (occupied.has(packCellKey(neighbour[0], neighbour[1], neighbour[2]))) continue;
+			const k = cell[d];
+			const iu = cell[u];
+			const iv = cell[v];
+			let slice = slices.get(k);
+			if (!slice) {
+				slice = /* @__PURE__ */ new Map();
+				slices.set(k, slice);
+			}
+			slice.set(packCellKey(iu, iv, 0), [iu, iv]);
+		}
+		for (const [k, slice] of [...slices.entries()].sort((a, b) => a[0] - b[0])) greedyMergeSlice(slice, half, cellSizeM, d, u, v, k, sign, positions, indices);
+	}
+}
+/** Greedy-merge one slice's exposed (iu,iv) mask into maximal rectangles. */
+function greedyMergeSlice(slice, half, cellSizeM, d, u, v, k, sign, positions, indices) {
+	const has = (iu, iv) => slice.has(packCellKey(iu, iv, 0));
+	const used = /* @__PURE__ */ new Set();
+	const isUsed = (iu, iv) => used.has(packCellKey(iu, iv, 0));
+	const p = [
+		0,
+		0,
+		0
+	];
+	const cells = [...slice.values()].sort((a, b) => a[1] !== b[1] ? a[1] - b[1] : a[0] - b[0]);
+	for (const [iu, iv] of cells) {
+		if (isUsed(iu, iv)) continue;
+		let w = 1;
+		while (has(iu + w, iv) && !isUsed(iu + w, iv)) w++;
+		let h = 1;
+		let canGrow = true;
+		while (canGrow) {
+			for (let du = 0; du < w; du++) {
+				if (has(iu + du, iv + h) && !isUsed(iu + du, iv + h)) continue;
+				canGrow = false;
+				break;
+			}
+			if (canGrow) h++;
+		}
+		for (let dv = 0; dv < h; dv++) for (let du = 0; du < w; du++) used.add(packCellKey(iu + du, iv + dv, 0));
+		const plane = k * cellSizeM + sign * half;
+		const uMin = iu * cellSizeM - half;
+		const uMax = (iu + w - 1) * cellSizeM + half;
+		const vMin = iv * cellSizeM - half;
+		const vMax = (iv + h - 1) * cellSizeM + half;
+		const base = positions.length / 3;
+		p[d] = plane;
+		p[u] = uMin;
+		p[v] = vMin;
+		positions.push(p[0], p[1], p[2]);
+		if (sign > 0) {
+			p[u] = uMax;
+			positions.push(p[0], p[1], p[2]);
+			p[v] = vMax;
+			positions.push(p[0], p[1], p[2]);
+			p[u] = uMin;
+			positions.push(p[0], p[1], p[2]);
+		} else {
+			p[v] = vMax;
+			positions.push(p[0], p[1], p[2]);
+			p[u] = uMax;
+			positions.push(p[0], p[1], p[2]);
+			p[v] = vMin;
+			positions.push(p[0], p[1], p[2]);
+		}
+		indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+	}
+}
+//#endregion
+export { meshOccupiedCells };

package/dist/ar/planar-pnp.d.ts

@@ -1,2 +1,2 @@
-import { a as homographyFromCorrespondences, c as rotationToRodrigues, i as PoseCandidate, l as solveLinear, n as Mat3, o as ippePoseCandidates, r as PlanarPnpSquare, s as nearestRotation3x3, t as Homography } from "../planar-pnp-my9bqULS.js";
+import { a as homographyFromCorrespondences, c as rotationToRodrigues, i as PoseCandidate, l as solveLinear, n as Mat3, o as ippePoseCandidates, r as PlanarPnpSquare, s as nearestRotation3x3, t as Homography } from "../planar-pnp-D7bc_rLX.js";
 export { Homography, Mat3, PlanarPnpSquare, PoseCandidate, homographyFromCorrespondences, ippePoseCandidates, nearestRotation3x3, rotationToRodrigues, solveLinear };

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

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

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

@@ -1,2 +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";
+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-BwNWn8oV.js";
 export { DeriveQrPoseDeps, DerivedQrPlacement, IncrementalQrPlacement, RawQrObservation, createIncrementalQrPlacement, deriveQrPlacement, deriveQrSizeM, deriveSolvedQrPose, solveQrPoseFromObservation };

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

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

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

@@ -1,2 +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";
+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-BPURlh3S.js";
 export { BarcodeDetectorFrontEnd, BarcodeDetectorLike, DetectedBarcodeLike, QrDetection, QrFrontEnd, RgbaImage, ToImageBitmapSource, createBarcodeDetectorFrontEnd };

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

@@ -1,2 +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";
+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-y3vaEd6x.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-size-depth-context.d.ts

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

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

@@ -1,2 +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";
+import { a as QrSizeMeasurerOptions, i as QrSizeMeasurer, n as QrSizeDepthContext, o as createQrSizeMeasurer, r as QrSizeMeasurement, t as ImageSize } from "../qr-size-measurer-DxiMqRUw.js";
 export { ImageSize, QrSizeDepthContext, QrSizeMeasurement, QrSizeMeasurer, QrSizeMeasurerOptions, 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-DBlDrV_x.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-zJ8SFDjE.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 { D as setCamera, E as setArWorldGroup, N as setScene, T as setArPose, i as createSceneHierarchy } from "../webxr-session-DG-eNfny.js";
+import { A as setArWorldGroup, L as setScene, j as setCamera, k as setArPose, s as createSceneHierarchy } from "../webxr-session-BCP2XK7k.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-BiShOQDB.js";
+import { t as SCENE_NODE } from "../scene-node-names-CGb-ylBd.js";
 export { SCENE_NODE };