framefields 2.0.2

package/dist/renderer-XcmYTd6P.mjs

@@ -0,0 +1,3818 @@
+import { At as programmaticSignal, vt as frameSignal } from "./dist-Bx6J0VcM.mjs";
+import { n as defineRenderer } from "./renderer-CtVkU_GA.mjs";
+import { a as PoseSkeletonComputePipeline } from "./dist-C_hjvkdN.mjs";
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+
+//#region ../vision/dist/registry-CSFimt7C.mjs
+const hf = (repo, revision, path$1) => `https://huggingface.co/${repo}/resolve/${revision}/${path$1}`;
+const RTMDET_INS_REPO = "tori29umai/rtmdet-ins-onnx-person-masks";
+const RTMDET_INS_REV = "e5218e8d47d7c50077f27f9893a28e0ef2ad5656";
+const RTMDET_INS_SOURCE = "RTMDet-Ins (OpenMMLab mmdetection, Apache-2.0), mmdeploy ONNX export";
+const RTMO_SOURCE = "RTMO (OpenMMLab mmpose, Apache-2.0), ONNX export";
+const SELFIE_SOURCE = "MediaPipe Selfie Segmenter (Google, Apache-2.0), ONNX export";
+const VISION_MODELS = {
+	"rtmdet-ins-t": {
+		key: "rtmdet-ins-t",
+		family: "rtmdet-ins",
+		filename: "rtmdet-ins-t.onnx",
+		url: hf(RTMDET_INS_REPO, RTMDET_INS_REV, "models/tiny/rtmdet-ins_tiny_640x640.onnx"),
+		bytes: 24032356,
+		sha256: "99ee670820c4493aa13e20578b6a8e39781c319846dc41796a77765734beac5c",
+		input: [640, 640],
+		source: RTMDET_INS_SOURCE
+	},
+	"rtmdet-ins-s": {
+		key: "rtmdet-ins-s",
+		family: "rtmdet-ins",
+		filename: "rtmdet-ins-s.onnx",
+		url: hf(RTMDET_INS_REPO, RTMDET_INS_REV, "models/s/rtmdet-ins_s_640x640.onnx"),
+		bytes: 43236976,
+		sha256: "9cd1787fbf3eb2bd64cc2d8154f41c036f5484b85599e1cbe0227a2dc5a4a08b",
+		input: [640, 640],
+		source: RTMDET_INS_SOURCE
+	},
+	"rtmdet-ins-m": {
+		key: "rtmdet-ins-m",
+		family: "rtmdet-ins",
+		filename: "rtmdet-ins-m.onnx",
+		url: hf(RTMDET_INS_REPO, RTMDET_INS_REV, "models/m/rtmdet-ins_m_640x640.onnx"),
+		bytes: 115735979,
+		sha256: "a003bce80316e03467c2c2b483df2d5c0398220c2357a44f9bf985929f7eb052",
+		input: [640, 640],
+		source: RTMDET_INS_SOURCE
+	},
+	"rtmo-t": {
+		key: "rtmo-t",
+		family: "rtmo",
+		filename: "rtmo-t.onnx",
+		url: hf("Xenova/RTMO-t", "f29d13ce5ee291fbe505e9d06a049992f05699dc", "onnx/model.onnx"),
+		bytes: 27360569,
+		sha256: "cb54dd042bf997df86d938721c94238940f2bff98ba8d2ccc834430de5c65c13",
+		input: [416, 416],
+		source: RTMO_SOURCE
+	},
+	"rtmo-s": {
+		key: "rtmo-s",
+		family: "rtmo",
+		filename: "rtmo-s.onnx",
+		url: hf("Xenova/RTMO-s", "d8c526187f341d287753831c9c8b1ecc4855bba1", "onnx/model.onnx"),
+		bytes: 39636400,
+		sha256: "1cd6a3517658903233e9ccb78666554862f57f0944b6886e2048093594aef4e7",
+		input: [640, 640],
+		source: RTMO_SOURCE
+	},
+	"rtmo-m": {
+		key: "rtmo-m",
+		family: "rtmo",
+		filename: "rtmo-m.onnx",
+		url: hf("Xenova/RTMO-m", "3aba1280472b98ee2bf663482e27e243038d23fe", "onnx/model.onnx"),
+		bytes: 89291929,
+		sha256: "76d82c45e5c4810baf587ecf2638d15cbf7ed196afb2055e977382532021b59e",
+		input: [640, 640],
+		source: RTMO_SOURCE
+	},
+	"selfie-square": {
+		key: "selfie-square",
+		family: "selfie",
+		filename: "selfie-square.onnx",
+		url: hf("onnx-community/mediapipe_selfie_segmentation", "be49485c8e027524be38591817fc5cd31bd9d00e", "onnx/model.onnx"),
+		bytes: 462352,
+		sha256: "3241ac4ad8aa35bdaf33946776db29f7c283a413aa0b0dacb9483594b4531aad",
+		input: [256, 256],
+		source: SELFIE_SOURCE
+	},
+	"selfie-landscape": {
+		key: "selfie-landscape",
+		family: "selfie",
+		filename: "selfie-landscape.onnx",
+		url: hf("onnx-community/mediapipe_selfie_segmentation_landscape", "2497d5bec26c626c7b3c4edc6e1fefc21b64f6c3", "onnx/model.onnx"),
+		bytes: 462338,
+		sha256: "7a0adcfdb1715d3b0ff0f61486d8a181c33f4a208343a5abfccbc6540e872d24",
+		input: [256, 144],
+		source: SELFIE_SOURCE
+	}
+};
+/**
+* Resolves the model for a task. `detect` and `segment` share RTMDet-Ins (one forward pass
+* yields both); `matte` picks the landscape Selfie Segmenter for wide frames.
+*/
+function modelKeyFor(task, variant = "s", aspect = 1) {
+	if (task === "pose") return `rtmo-${variant}`;
+	if (task === "matte") return aspect > 1.3 ? "selfie-landscape" : "selfie-square";
+	return `rtmdet-ins-${variant}`;
+}
+/** COCO 80 class names — index order matches the RTMDet-Ins `labels` output. */
+const COCO_CLASSES = [
+	"person",
+	"bicycle",
+	"car",
+	"motorcycle",
+	"airplane",
+	"bus",
+	"train",
+	"truck",
+	"boat",
+	"traffic light",
+	"fire hydrant",
+	"stop sign",
+	"parking meter",
+	"bench",
+	"bird",
+	"cat",
+	"dog",
+	"horse",
+	"sheep",
+	"cow",
+	"elephant",
+	"bear",
+	"zebra",
+	"giraffe",
+	"backpack",
+	"umbrella",
+	"handbag",
+	"tie",
+	"suitcase",
+	"frisbee",
+	"skis",
+	"snowboard",
+	"sports ball",
+	"kite",
+	"baseball bat",
+	"baseball glove",
+	"skateboard",
+	"surfboard",
+	"tennis racket",
+	"bottle",
+	"wine glass",
+	"cup",
+	"fork",
+	"knife",
+	"spoon",
+	"bowl",
+	"banana",
+	"apple",
+	"sandwich",
+	"orange",
+	"broccoli",
+	"carrot",
+	"hot dog",
+	"pizza",
+	"donut",
+	"cake",
+	"chair",
+	"couch",
+	"potted plant",
+	"bed",
+	"dining table",
+	"toilet",
+	"tv",
+	"laptop",
+	"mouse",
+	"remote",
+	"keyboard",
+	"cell phone",
+	"microwave",
+	"oven",
+	"toaster",
+	"sink",
+	"refrigerator",
+	"book",
+	"clock",
+	"vase",
+	"scissors",
+	"teddy bear",
+	"hair drier",
+	"toothbrush"
+];
+
+//#endregion
+//#region ../vision/dist/src-DbPyIIat.mjs
+function computeIoU(boxA, boxB) {
+	const xA = Math.max(boxA.originX, boxB.originX);
+	const yA = Math.max(boxA.originY, boxB.originY);
+	const xB = Math.min(boxA.originX + boxA.width, boxB.originX + boxB.width);
+	const yB = Math.min(boxA.originY + boxA.height, boxB.originY + boxB.height);
+	const interArea = Math.max(0, xB - xA) * Math.max(0, yB - yA);
+	if (interArea <= 0) return 0;
+	const unionArea = boxA.width * boxA.height + boxB.width * boxB.height - interArea;
+	return unionArea > 0 ? interArea / unionArea : 0;
+}
+var TemporalObjectTracker = class {
+	_nextTrackId = 1;
+	_tracks = [];
+	_iouThreshold;
+	_maxMissedFrames;
+	_minHits;
+	_positionSmoothing;
+	_activeDuringCoast;
+	constructor(options = {}) {
+		this._iouThreshold = options.iouThreshold ?? .25;
+		this._maxMissedFrames = options.maxMissedFrames ?? 15;
+		this._minHits = options.minHits ?? 1;
+		this._positionSmoothing = Math.max(.1, Math.min(1, options.positionSmoothing ?? .75));
+		this._activeDuringCoast = options.activeDuringCoast !== false;
+	}
+	/**
+	* Updates the multi-object tracker with new detections for the current frame.
+	*
+	* @param detections Raw detections found on the current frame
+	* @param frame Current frame index
+	* @param fps Video framerate (used for physical velocity estimation)
+	* @returns Stable, temporal list of TrackedObjects
+	*/
+	update(detections, _frame, fps = 24) {
+		const dt = fps > 0 ? 1 / fps : .0416;
+		for (const track of this._tracks) {
+			track.age++;
+			track.timeSinceUpdate++;
+			if (track.timeSinceUpdate > 0) {
+				const predCenterX = track.centerX + track.vx * dt;
+				const predCenterY = track.centerY + track.vy * dt;
+				track.centerX = predCenterX;
+				track.centerY = predCenterY;
+				const w = track.box.width;
+				const h = track.box.height;
+				const normW = track.box.normalizedWidth;
+				const normH = track.box.normalizedHeight;
+				const normCenterX = track.box.normalizedX + normW / 2 + track.vx * dt / Math.max(1, track.box.width / normW);
+				const normCenterY = track.box.normalizedY + normH / 2 + track.vy * dt / Math.max(1, track.box.height / normH);
+				track.box = {
+					originX: predCenterX - w / 2,
+					originY: predCenterY - h / 2,
+					width: w,
+					height: h,
+					normalizedX: normCenterX - normW / 2,
+					normalizedY: normCenterY - normH / 2,
+					normalizedWidth: normW,
+					normalizedHeight: normH
+				};
+				track.vx *= .92;
+				track.vy *= .92;
+				track.isCoasting = true;
+			}
+		}
+		const matchedDetections = /* @__PURE__ */ new Set();
+		const matchedTracks = /* @__PURE__ */ new Set();
+		const candidateMatches = [];
+		for (let t = 0; t < this._tracks.length; t++) {
+			const trk = this._tracks[t];
+			for (let d = 0; d < detections.length; d++) {
+				const det = detections[d];
+				if (trk.category !== det.category) continue;
+				const iou = computeIoU(trk.box, det.boundingBox);
+				if (iou >= this._iouThreshold) candidateMatches.push({
+					trackIdx: t,
+					detIdx: d,
+					iou
+				});
+			}
+		}
+		candidateMatches.sort((a, b) => b.iou - a.iou);
+		for (const match of candidateMatches) {
+			if (matchedTracks.has(match.trackIdx) || matchedDetections.has(match.detIdx)) continue;
+			matchedTracks.add(match.trackIdx);
+			matchedDetections.add(match.detIdx);
+			const trk = this._tracks[match.trackIdx];
+			const det = detections[match.detIdx];
+			const detBox = det.boundingBox;
+			const detCenterX = detBox.originX + detBox.width / 2;
+			const detCenterY = detBox.originY + detBox.height / 2;
+			const instVx = (detCenterX - trk.centerX) / dt;
+			const instVy = (detCenterY - trk.centerY) / dt;
+			trk.vx = trk.vx * .4 + instVx * .6;
+			trk.vy = trk.vy * .4 + instVy * .6;
+			const alpha = this._positionSmoothing;
+			const smoothW = trk.box.width * (1 - alpha) + detBox.width * alpha;
+			const smoothH = trk.box.height * (1 - alpha) + detBox.height * alpha;
+			const smoothCenterX = trk.centerX * (1 - alpha) + detCenterX * alpha;
+			const smoothCenterY = trk.centerY * (1 - alpha) + detCenterY * alpha;
+			trk.centerX = smoothCenterX;
+			trk.centerY = smoothCenterY;
+			trk.score = det.score;
+			trk.timeSinceUpdate = 0;
+			trk.hits++;
+			trk.isCoasting = false;
+			if (trk.hits >= this._minHits) trk.active = true;
+			trk.box = {
+				originX: smoothCenterX - smoothW / 2,
+				originY: smoothCenterY - smoothH / 2,
+				width: smoothW,
+				height: smoothH,
+				normalizedX: detBox.normalizedX,
+				normalizedY: detBox.normalizedY,
+				normalizedWidth: detBox.normalizedWidth,
+				normalizedHeight: detBox.normalizedHeight
+			};
+		}
+		for (let d = 0; d < detections.length; d++) {
+			if (matchedDetections.has(d)) continue;
+			const det = detections[d];
+			const detBox = det.boundingBox;
+			const centerX = detBox.originX + detBox.width / 2;
+			const centerY = detBox.originY + detBox.height / 2;
+			this._tracks.push({
+				trackId: this._nextTrackId++,
+				category: det.category,
+				score: det.score,
+				box: detBox,
+				centerX,
+				centerY,
+				vx: 0,
+				vy: 0,
+				age: 1,
+				hits: 1,
+				timeSinceUpdate: 0,
+				active: this._minHits <= 1,
+				isCoasting: false
+			});
+		}
+		this._tracks = this._tracks.filter((t) => t.timeSinceUpdate <= this._maxMissedFrames);
+		return this._tracks.filter((t) => t.active).map((t) => {
+			const normW = t.box.normalizedWidth;
+			const normH = t.box.normalizedHeight;
+			const normCenterX = t.box.normalizedX + normW / 2;
+			const normCenterY = t.box.normalizedY + normH / 2;
+			const speed = Math.sqrt(t.vx * t.vx + t.vy * t.vy);
+			return {
+				trackId: t.trackId,
+				category: t.category,
+				score: t.score,
+				boundingBox: t.box,
+				centerX: t.centerX,
+				centerY: t.centerY,
+				normalizedCenterX: normCenterX,
+				normalizedCenterY: normCenterY,
+				velocity: {
+					vx: t.vx,
+					vy: t.vy
+				},
+				speed,
+				age: t.age,
+				hits: t.hits,
+				active: this._activeDuringCoast ? true : t.timeSinceUpdate === 0,
+				isCoasting: t.isCoasting
+			};
+		});
+	}
+	/**
+	* Tracks objects across a full sequence of frames with gap interpolation,
+	* boundary extrapolation (ensuring frame 0 through end are tracked),
+	* and temporal Gaussian smoothing.
+	*
+	* Guarantees zero flicker, zero drift, and frame-accurate stability across the entire video.
+	*/
+	trackSequence(perFrameDetections, totalFrames, fps = 24) {
+		this.reset();
+		const dt = fps > 0 ? 1 / fps : .0416;
+		const trackHistory = /* @__PURE__ */ new Map();
+		for (let f = 0; f < totalFrames; f++) {
+			const dets = perFrameDetections[f] ?? [];
+			const stepTracks = this.update(dets, f, fps);
+			for (const trk of stepTracks) {
+				if (!trackHistory.has(trk.trackId)) trackHistory.set(trk.trackId, {
+					category: trk.category,
+					observations: []
+				});
+				if (!trk.isCoasting) trackHistory.get(trk.trackId).observations.push({
+					frame: f,
+					box: trk.boundingBox,
+					score: trk.score
+				});
+			}
+		}
+		const fullTrajectories = /* @__PURE__ */ new Map();
+		for (const [trackId, info] of trackHistory.entries()) {
+			const obs = info.observations;
+			if (obs.length === 0) continue;
+			obs.sort((a, b) => a.frame - b.frame);
+			const frameData = new Array(totalFrames).fill(null);
+			for (const o of obs) frameData[o.frame] = {
+				box: o.box,
+				score: o.score
+			};
+			const firstObs = obs[0];
+			for (let f = 0; f < firstObs.frame; f++) frameData[f] = {
+				box: { ...firstObs.box },
+				score: firstObs.score * .9
+			};
+			for (let i = 0; i < obs.length - 1; i++) {
+				const startObs = obs[i];
+				const endObs = obs[i + 1];
+				const gap = endObs.frame - startObs.frame;
+				if (gap <= 1) continue;
+				for (let f = startObs.frame + 1; f < endObs.frame; f++) {
+					const t = (f - startObs.frame) / gap;
+					frameData[f] = {
+						box: {
+							originX: startObs.box.originX + (endObs.box.originX - startObs.box.originX) * t,
+							originY: startObs.box.originY + (endObs.box.originY - startObs.box.originY) * t,
+							width: startObs.box.width + (endObs.box.width - startObs.box.width) * t,
+							height: startObs.box.height + (endObs.box.height - startObs.box.height) * t,
+							normalizedX: startObs.box.normalizedX + (endObs.box.normalizedX - startObs.box.normalizedX) * t,
+							normalizedY: startObs.box.normalizedY + (endObs.box.normalizedY - startObs.box.normalizedY) * t,
+							normalizedWidth: startObs.box.normalizedWidth + (endObs.box.normalizedWidth - startObs.box.normalizedWidth) * t,
+							normalizedHeight: startObs.box.normalizedHeight + (endObs.box.normalizedHeight - startObs.box.normalizedHeight) * t
+						},
+						score: startObs.score * (1 - t) + endObs.score * t
+					};
+				}
+			}
+			const lastObs = obs[obs.length - 1];
+			for (let f = lastObs.frame + 1; f < totalFrames; f++) frameData[f] = {
+				box: { ...lastObs.box },
+				score: lastObs.score * .9
+			};
+			const smoothedFrames = [];
+			const radius = 2;
+			const weights = [
+				.06136,
+				.24477,
+				.38774,
+				.24477,
+				.06136
+			];
+			for (let f = 0; f < totalFrames; f++) {
+				let sumWeight = 0;
+				let sumX = 0;
+				let sumY = 0;
+				let sumW = 0;
+				let sumH = 0;
+				let sumNormX = 0;
+				let sumNormY = 0;
+				let sumNormW = 0;
+				let sumNormH = 0;
+				let sumScore = 0;
+				for (let r = -radius; r <= radius; r++) {
+					const pt = frameData[Math.max(0, Math.min(totalFrames - 1, f + r))];
+					if (pt) {
+						const w = weights[r + radius];
+						sumWeight += w;
+						sumX += pt.box.originX * w;
+						sumY += pt.box.originY * w;
+						sumW += pt.box.width * w;
+						sumH += pt.box.height * w;
+						sumNormX += pt.box.normalizedX * w;
+						sumNormY += pt.box.normalizedY * w;
+						sumNormW += pt.box.normalizedWidth * w;
+						sumNormH += pt.box.normalizedHeight * w;
+						sumScore += pt.score * w;
+					}
+				}
+				const invW = sumWeight > 0 ? 1 / sumWeight : 1;
+				smoothedFrames.push({
+					box: {
+						originX: sumX * invW,
+						originY: sumY * invW,
+						width: sumW * invW,
+						height: sumH * invW,
+						normalizedX: sumNormX * invW,
+						normalizedY: sumNormY * invW,
+						normalizedWidth: sumNormW * invW,
+						normalizedHeight: sumNormH * invW
+					},
+					score: sumScore * invW
+				});
+			}
+			fullTrajectories.set(trackId, {
+				category: info.category,
+				frames: smoothedFrames
+			});
+		}
+		const result = [];
+		for (let f = 0; f < totalFrames; f++) {
+			const frameObjects = [];
+			for (const [trackId, traj] of fullTrajectories.entries()) {
+				const current = traj.frames[f];
+				if (!current) continue;
+				const prev = traj.frames[Math.max(0, f - 1)] ?? current;
+				const next = traj.frames[Math.min(totalFrames - 1, f + 1)] ?? current;
+				const curCenterX = current.box.originX + current.box.width / 2;
+				const curCenterY = current.box.originY + current.box.height / 2;
+				const prevCenterX = prev.box.originX + prev.box.width / 2;
+				const prevCenterY = prev.box.originY + prev.box.height / 2;
+				const nextCenterX = next.box.originX + next.box.width / 2;
+				const nextCenterY = next.box.originY + next.box.height / 2;
+				const timeDelta = f === 0 || f === totalFrames - 1 ? dt : 2 * dt;
+				const vx = (nextCenterX - prevCenterX) / timeDelta;
+				const vy = (nextCenterY - prevCenterY) / timeDelta;
+				const speed = Math.sqrt(vx * vx + vy * vy);
+				const normW = current.box.normalizedWidth;
+				const normH = current.box.normalizedHeight;
+				frameObjects.push({
+					trackId,
+					category: traj.category,
+					score: current.score,
+					boundingBox: current.box,
+					centerX: curCenterX,
+					centerY: curCenterY,
+					normalizedCenterX: current.box.normalizedX + normW / 2,
+					normalizedCenterY: current.box.normalizedY + normH / 2,
+					velocity: {
+						vx,
+						vy
+					},
+					speed,
+					age: f + 1,
+					hits: 10,
+					active: true,
+					isCoasting: false
+				});
+			}
+			result.push(frameObjects);
+		}
+		return result;
+	}
+	/**
+	* Resets all internal track state.
+	*/
+	reset() {
+		this._tracks = [];
+		this._nextTrackId = 1;
+	}
+};
+const now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+async function analyzeSequence(frames, options) {
+	const { runner } = options;
+	const fps = options.fps ?? 24;
+	const tasks = options.tasks && options.tasks.length > 0 ? options.tasks : ["detect"];
+	const taskSet = new Set(tasks);
+	const categoryFilter = options.categories ? new Set(options.categories.map((c) => c.toLowerCase())) : null;
+	const includeMasks = options.includeMasks === true && taskSet.has("segment");
+	const tracksObjects = taskSet.has("detect") || taskSet.has("segment");
+	const perFrameDetections = [];
+	const modelDownloads = {};
+	const maskCoverage = /* @__PURE__ */ new Map();
+	let inferenceMs = 0;
+	let frameIndex = 0;
+	const accepts = (category) => !categoryFilter || categoryFilter.has(category.toLowerCase());
+	const runTask = async (task, frame, fn) => {
+		const key = runner.modelKeyFor(task, frame.width / frame.height);
+		const wasReady = runner.downloadStatus.get(key) === "ready";
+		const start = now();
+		const result = await fn();
+		const elapsed = now() - start;
+		inferenceMs += elapsed;
+		if (!wasReady && !modelDownloads[key]) modelDownloads[key] = {
+			bytes: VISION_MODELS[key].bytes,
+			ms: elapsed
+		};
+		return result;
+	};
+	const recordMasks = (masks$1) => {
+		for (const m of masks$1) {
+			if (!accepts(m.category)) continue;
+			const entry = maskCoverage.get(m.category) ?? {
+				sum: 0,
+				count: 0
+			};
+			entry.sum += m.coverage;
+			entry.count++;
+			maskCoverage.set(m.category, entry);
+		}
+	};
+	for await (const frame of frames) {
+		let detections = [];
+		if (includeMasks) {
+			const seg = await runTask("segment", frame, () => runner.segment(frame));
+			recordMasks(seg.masks);
+			detections = seg.detections;
+		} else if (tracksObjects) detections = await runTask("detect", frame, () => runner.detect(frame));
+		if (taskSet.has("pose")) await runTask("pose", frame, () => runner.pose(frame));
+		if (taskSet.has("matte")) await runTask("matte", frame, () => runner.matte(frame));
+		perFrameDetections.push(categoryFilter ? detections.filter((d) => accepts(d.category)) : detections);
+		frameIndex++;
+	}
+	const totalFrames = frameIndex;
+	const trackedPerFrame = new TemporalObjectTracker({
+		iouThreshold: options.iouThreshold ?? .25,
+		maxMissedFrames: options.maxMissedFrames ?? 15
+	}).trackSequence(perFrameDetections, totalFrames, fps);
+	const pathStride = options.pathStride ?? Math.max(1, Math.ceil(totalFrames / 50));
+	const tracks = /* @__PURE__ */ new Map();
+	const classPresentFrames = /* @__PURE__ */ new Map();
+	const classMaxConfidence = /* @__PURE__ */ new Map();
+	const classTrackIds = /* @__PURE__ */ new Map();
+	const getOrCreate = (map, key, make) => {
+		let value = map.get(key);
+		if (value === void 0) {
+			value = make();
+			map.set(key, value);
+		}
+		return value;
+	};
+	for (let f = 0; f < totalFrames; f++) for (const obj of trackedPerFrame[f] ?? []) {
+		if (!accepts(obj.category)) continue;
+		let acc = tracks.get(obj.trackId);
+		if (!acc) {
+			acc = {
+				category: obj.category,
+				firstFrame: f,
+				lastFrame: f,
+				speedSum: 0,
+				speedCount: 0,
+				centers: []
+			};
+			tracks.set(obj.trackId, acc);
+		}
+		acc.lastFrame = f;
+		if (Number.isFinite(obj.speed)) {
+			acc.speedSum += obj.speed;
+			acc.speedCount++;
+		}
+		if ((f - acc.firstFrame) % pathStride === 0) acc.centers.push({
+			frame: f,
+			x: obj.centerX,
+			y: obj.centerY
+		});
+		getOrCreate(classPresentFrames, obj.category, () => /* @__PURE__ */ new Set()).add(f);
+		classMaxConfidence.set(obj.category, Math.max(classMaxConfidence.get(obj.category) ?? 0, obj.score));
+		getOrCreate(classTrackIds, obj.category, () => /* @__PURE__ */ new Set()).add(obj.trackId);
+	}
+	const trackSummaries = Array.from(tracks.entries()).map(([trackId, acc]) => ({
+		trackId,
+		category: acc.category,
+		frames: [acc.firstFrame, acc.lastFrame],
+		speedMeanPxS: acc.speedCount > 0 ? acc.speedSum / acc.speedCount : 0,
+		centerPath: acc.centers.map((c) => [c.x, c.y])
+	})).sort((a, b) => a.trackId - b.trackId);
+	const classes = {};
+	for (const [category, frameSet] of classPresentFrames) classes[category] = {
+		framesPresent: frameSet.size,
+		totalFrames,
+		maxConfidence: classMaxConfidence.get(category) ?? 0,
+		tracks: classTrackIds.get(category)?.size ?? 0
+	};
+	const masks = {};
+	for (const [category, entry] of maskCoverage) masks[category] = { meanCoverage: entry.count > 0 ? entry.sum / entry.count : 0 };
+	return {
+		source: options.source ?? "frames",
+		totalFrames,
+		fps,
+		durationSec: fps > 0 ? totalFrames / fps : 0,
+		tasks: Array.from(taskSet),
+		modelDownloads,
+		inferenceMs,
+		trackCount: trackSummaries.length,
+		classes,
+		tracks: trackSummaries,
+		masks
+	};
+}
+const IMAGENET_BGR_MEAN = [
+	103.53,
+	116.28,
+	123.675
+];
+const IMAGENET_BGR_STD = [
+	57.375,
+	57.12,
+	58.395
+];
+/** Per-family normalization; the input size always comes from the model's registry entry. */
+const PREPROCESS_BY_FAMILY = {
+	"rtmdet-ins": {
+		fit: "topLeft",
+		channels: "bgr",
+		mean: IMAGENET_BGR_MEAN,
+		std: IMAGENET_BGR_STD,
+		padValue: 114
+	},
+	rtmo: {
+		fit: "center",
+		channels: "bgr",
+		mean: [
+			0,
+			0,
+			0
+		],
+		std: [
+			1,
+			1,
+			1
+		],
+		padValue: 114
+	},
+	selfie: {
+		fit: "stretch",
+		channels: "rgb",
+		mean: [
+			0,
+			0,
+			0
+		],
+		std: [
+			255,
+			255,
+			255
+		],
+		padValue: 0
+	}
+};
+function preprocessSpec(family, input) {
+	return {
+		...PREPROCESS_BY_FAMILY[family],
+		width: input[0],
+		height: input[1]
+	};
+}
+function computeInputTransform(srcW, srcH, spec) {
+	if (spec.fit === "stretch") return {
+		scaleX: spec.width / srcW,
+		scaleY: spec.height / srcH,
+		offsetX: 0,
+		offsetY: 0,
+		inputWidth: spec.width,
+		inputHeight: spec.height
+	};
+	const scale = Math.min(spec.width / srcW, spec.height / srcH);
+	const contentW = Math.round(srcW * scale);
+	const contentH = Math.round(srcH * scale);
+	const center = spec.fit === "center";
+	return {
+		scaleX: scale,
+		scaleY: scale,
+		offsetX: center ? (spec.width - contentW) / 2 : 0,
+		offsetY: center ? (spec.height - contentH) / 2 : 0,
+		inputWidth: spec.width,
+		inputHeight: spec.height
+	};
+}
+/** Model-input point → source pixel point. */
+function toSourcePoint(x, y, t) {
+	return {
+		x: (x - t.offsetX) / t.scaleX,
+		y: (y - t.offsetY) / t.scaleY
+	};
+}
+/**
+* Resizes RGBA → NCHW float32 `[1, 3, height, width]` with bilinear sampling, padding,
+* channel reordering and normalization per `spec`. Reuses `out` when large enough
+* (hot-path frame loop).
+*/
+function imageToTensor(image, spec, out) {
+	const { width: srcW, height: srcH, data: src } = image;
+	const { width: W, height: H } = spec;
+	const transform = computeInputTransform(srcW, srcH, spec);
+	const { scaleX, scaleY, offsetX, offsetY } = transform;
+	const plane = W * H;
+	if (!out || out.length < 3 * plane) out = new Float32Array(3 * plane);
+	const order = spec.channels === "bgr" ? [
+		2,
+		1,
+		0
+	] : [
+		0,
+		1,
+		2
+	];
+	const [m0, m1, m2] = spec.mean;
+	const inv0 = 1 / spec.std[0];
+	const inv1 = 1 / spec.std[1];
+	const inv2 = 1 / spec.std[2];
+	const pad0 = (spec.padValue - m0) * inv0;
+	const pad1 = (spec.padValue - m1) * inv1;
+	const pad2 = (spec.padValue - m2) * inv2;
+	const [c0, c1, c2] = order;
+	const x0 = Math.ceil(offsetX);
+	const y0 = Math.ceil(offsetY);
+	const x1 = Math.min(W, Math.floor(offsetX + srcW * scaleX)) - 1;
+	const y1 = Math.min(H, Math.floor(offsetY + srcH * scaleY)) - 1;
+	for (let y = 0; y < H; y++) {
+		const rowBase = y * W;
+		const paddedRow = y < y0 || y > y1;
+		const sy = Math.max(0, (y + .5 - offsetY) / scaleY - .5);
+		const iy0 = Math.min(srcH - 1, Math.floor(sy));
+		const iy1 = Math.min(srcH - 1, iy0 + 1);
+		const fy = sy - iy0;
+		for (let x = 0; x < W; x++) {
+			const o = rowBase + x;
+			if (paddedRow || x < x0 || x > x1) {
+				out[o] = pad0;
+				out[plane + o] = pad1;
+				out[2 * plane + o] = pad2;
+				continue;
+			}
+			const sx = Math.max(0, (x + .5 - offsetX) / scaleX - .5);
+			const ix0 = Math.min(srcW - 1, Math.floor(sx));
+			const ix1 = Math.min(srcW - 1, ix0 + 1);
+			const fx = sx - ix0;
+			const i00 = (iy0 * srcW + ix0) * 4;
+			const i10 = (iy0 * srcW + ix1) * 4;
+			const i01 = (iy1 * srcW + ix0) * 4;
+			const i11 = (iy1 * srcW + ix1) * 4;
+			const w00 = (1 - fx) * (1 - fy);
+			const w10 = fx * (1 - fy);
+			const w01 = (1 - fx) * fy;
+			const w11 = fx * fy;
+			out[o] = (src[i00 + c0] * w00 + src[i10 + c0] * w10 + src[i01 + c0] * w01 + src[i11 + c0] * w11 - m0) * inv0;
+			out[plane + o] = (src[i00 + c1] * w00 + src[i10 + c1] * w10 + src[i01 + c1] * w01 + src[i11 + c1] * w11 - m1) * inv1;
+			out[2 * plane + o] = (src[i00 + c2] * w00 + src[i10 + c2] * w10 + src[i01 + c2] * w01 + src[i11 + c2] * w11 - m2) * inv2;
+		}
+	}
+	return {
+		tensor: out,
+		transform
+	};
+}
+/** Source pixels a mask may extend past its box (instance masks are not box-clipped). */
+const MASK_BOX_PAD_PX = 8;
+function decodeRtmdetIns(out, opts) {
+	const { sourceWidth: sw, sourceHeight: sh, transform } = opts;
+	const classFilter = opts.classes ? new Set(opts.classes.map((c) => c.toLowerCase())) : null;
+	const kept = [];
+	for (let i = 0; i < out.count; i++) {
+		const score = out.dets[i * 5 + 4];
+		if (!(score >= opts.confidence)) continue;
+		const classIndex = Number(out.labels[i]);
+		const category = opts.classNames[classIndex] ?? `class_${classIndex}`;
+		if (classFilter && !classFilter.has(category.toLowerCase())) continue;
+		const p0 = toSourcePoint(out.dets[i * 5], out.dets[i * 5 + 1], transform);
+		const p1 = toSourcePoint(out.dets[i * 5 + 2], out.dets[i * 5 + 3], transform);
+		const x0 = clamp$1(p0.x, 0, sw);
+		const y0 = clamp$1(p0.y, 0, sh);
+		const width = clamp$1(p1.x, 0, sw) - x0;
+		const height = clamp$1(p1.y, 0, sh) - y0;
+		if (width <= 0 || height <= 0) continue;
+		kept.push({
+			index: i,
+			detection: {
+				category,
+				score,
+				boundingBox: {
+					originX: x0,
+					originY: y0,
+					width,
+					height,
+					normalizedX: x0 / sw,
+					normalizedY: y0 / sh,
+					normalizedWidth: width / sw,
+					normalizedHeight: height / sh
+				}
+			}
+		});
+	}
+	kept.sort((a, b) => b.detection.score - a.detection.score);
+	const detections = kept.map((k) => k.detection);
+	const masks = [];
+	if (!out.masks) return {
+		detections,
+		masks
+	};
+	const alphaOf = probabilityToAlpha(opts.maskThreshold ?? .5, opts.featherRadius ?? .05);
+	const { maskWidth: mw, maskHeight: mh } = out;
+	const plane = mw * mh;
+	const gx = mw / transform.inputWidth;
+	const gy = mh / transform.inputHeight;
+	for (let d = 0; d < kept.length; d++) {
+		const { index, detection } = kept[d];
+		const box = detection.boundingBox;
+		const base = index * plane;
+		const bx0 = Math.max(0, Math.floor(box.originX) - MASK_BOX_PAD_PX);
+		const by0 = Math.max(0, Math.floor(box.originY) - MASK_BOX_PAD_PX);
+		const bx1 = Math.min(sw - 1, Math.ceil(box.originX + box.width) + MASK_BOX_PAD_PX);
+		const by1 = Math.min(sh - 1, Math.ceil(box.originY + box.height) + MASK_BOX_PAD_PX);
+		const mask = new Uint8Array(sw * sh);
+		let area = 0;
+		for (let sy = by0; sy <= by1; sy++) {
+			const my = ((sy + .5) * transform.scaleY + transform.offsetY) * gy - .5;
+			const my0 = clamp$1(Math.floor(my), 0, mh - 1);
+			const my1 = Math.min(mh - 1, my0 + 1);
+			const fy = clamp$1(my - my0, 0, 1);
+			const row = sy * sw;
+			for (let sx = bx0; sx <= bx1; sx++) {
+				const mx = ((sx + .5) * transform.scaleX + transform.offsetX) * gx - .5;
+				const mx0 = clamp$1(Math.floor(mx), 0, mw - 1);
+				const mx1 = Math.min(mw - 1, mx0 + 1);
+				const fx = clamp$1(mx - mx0, 0, 1);
+				const alpha = alphaOf(out.masks[base + my0 * mw + mx0] * (1 - fx) * (1 - fy) + out.masks[base + my0 * mw + mx1] * fx * (1 - fy) + out.masks[base + my1 * mw + mx0] * (1 - fx) * fy + out.masks[base + my1 * mw + mx1] * fx * fy);
+				if (alpha > 0) {
+					mask[row + sx] = alpha;
+					area += alpha / 255;
+				}
+			}
+		}
+		area = Math.round(area);
+		if (area === 0) continue;
+		masks.push({
+			category: detection.category,
+			mask,
+			width: sw,
+			height: sh,
+			area,
+			coverage: area / (sw * sh),
+			detectionIndex: d
+		});
+	}
+	return {
+		detections,
+		masks
+	};
+}
+/**
+* Probability → 0..255 alpha. A hard threshold when `feather` is 0, otherwise a linear ramp
+* across `[threshold − feather, threshold + feather]` for anti-aliased edges.
+*/
+function probabilityToAlpha(threshold, feather) {
+	if (feather <= 0) return (p) => p > threshold ? 255 : 0;
+	const lo = threshold - feather;
+	const inv = 255 / (2 * feather);
+	return (p) => p <= lo ? 0 : p >= threshold + feather ? 255 : (p - lo) * inv;
+}
+function clamp$1(v, lo, hi) {
+	return v < lo ? lo : v > hi ? hi : v;
+}
+const COCO17_KEYPOINT_COUNT = 17;
+/** Keypoint visibility at which a joint counts as seen. */
+const VISIBLE = .3;
+function decodeRtmo(out, opts) {
+	const { sourceWidth: sw, sourceHeight: sh, transform } = opts;
+	const stride = out.keypointStride;
+	const people = [];
+	for (let i = 0; i < out.count; i++) {
+		const score = out.dets[i * 5 + 4];
+		if (!(score >= opts.confidence)) continue;
+		const p0 = toSourcePoint(out.dets[i * 5], out.dets[i * 5 + 1], transform);
+		const p1 = toSourcePoint(out.dets[i * 5 + 2], out.dets[i * 5 + 3], transform);
+		const x0 = clamp(p0.x, 0, sw);
+		const y0 = clamp(p0.y, 0, sh);
+		const width = clamp(p1.x, 0, sw) - x0;
+		const height = clamp(p1.y, 0, sh) - y0;
+		if (width <= 0 || height <= 0) continue;
+		const keypoints = [];
+		const base = i * COCO17_KEYPOINT_COUNT * stride;
+		for (let k = 0; k < COCO17_KEYPOINT_COUNT; k++) {
+			const o = base + k * stride;
+			const p = toSourcePoint(out.keypoints[o], out.keypoints[o + 1], transform);
+			keypoints.push({
+				x: clamp(p.x, 0, sw),
+				y: clamp(p.y, 0, sh),
+				visibility: clamp(out.keypoints[o + 2], 0, 1)
+			});
+		}
+		let visible = 0;
+		for (const k of keypoints) if (k.visibility >= VISIBLE) visible++;
+		if (visible < (opts.minVisibleKeypoints ?? 3)) continue;
+		people.push({
+			score,
+			boundingBox: {
+				originX: x0,
+				originY: y0,
+				width,
+				height,
+				normalizedX: x0 / sw,
+				normalizedY: y0 / sh,
+				normalizedWidth: width / sw,
+				normalizedHeight: height / sh
+			},
+			keypoints
+		});
+	}
+	people.sort((a, b) => b.score - a.score);
+	const iou = opts.iouThreshold ?? .6;
+	const kept = [];
+	for (const p of people) if (!kept.some((k) => isDuplicate(k, p, iou))) kept.push(p);
+	return { people: kept };
+}
+function clamp(v, lo, hi) {
+	return v < lo ? lo : v > hi ? hi : v;
+}
+/**
+* Same person twice: boxes overlap above `iou`, or the joints both detections can see sit
+* within 10% of the stronger detection's box size of each other (boxes may differ when one
+* of them also covers a flowing garment or a shadow).
+*/
+function isDuplicate(a, b, iou) {
+	if (computeIoU(a.boundingBox, b.boundingBox) > iou) return true;
+	const scale = Math.sqrt(a.boundingBox.width * a.boundingBox.height);
+	let sum = 0;
+	let n = 0;
+	for (let k = 0; k < a.keypoints.length; k++) {
+		const ka = a.keypoints[k];
+		const kb = b.keypoints[k];
+		if (ka.visibility < VISIBLE || kb.visibility < VISIBLE) continue;
+		sum += Math.hypot(ka.x - kb.x, ka.y - kb.y);
+		n++;
+	}
+	return n >= 3 && sum / n < .1 * scale;
+}
+function decodeSelfie(alphas, matteWidth, matteHeight, opts) {
+	const { sourceWidth: sw, sourceHeight: sh } = opts;
+	const alphaOf = probabilityToAlpha(opts.maskThreshold ?? .5, opts.featherRadius ?? .2);
+	const mask = new Uint8Array(sw * sh);
+	const kx = matteWidth / sw;
+	const ky = matteHeight / sh;
+	let sum = 0;
+	for (let y = 0; y < sh; y++) {
+		const my = Math.max(0, (y + .5) * ky - .5);
+		const my0 = Math.min(matteHeight - 1, Math.floor(my));
+		const my1 = Math.min(matteHeight - 1, my0 + 1);
+		const fy = my - my0;
+		for (let x = 0; x < sw; x++) {
+			const mx = Math.max(0, (x + .5) * kx - .5);
+			const mx0 = Math.min(matteWidth - 1, Math.floor(mx));
+			const mx1 = Math.min(matteWidth - 1, mx0 + 1);
+			const fx = mx - mx0;
+			const a = alphaOf(alphas[my0 * matteWidth + mx0] * (1 - fx) * (1 - fy) + alphas[my0 * matteWidth + mx1] * fx * (1 - fy) + alphas[my1 * matteWidth + mx0] * (1 - fx) * fy + alphas[my1 * matteWidth + mx1] * fx * fy);
+			mask[y * sw + x] = a;
+			sum += a;
+		}
+	}
+	return {
+		mask,
+		width: sw,
+		height: sh,
+		coverage: sw * sh > 0 ? sum / (255 * sw * sh) : 0
+	};
+}
+/** COCO-17 keypoint indices (RTMO output order). */
+const COCO17_KEYPOINTS = {
+	NOSE: 0,
+	LEFT_EYE: 1,
+	RIGHT_EYE: 2,
+	LEFT_EAR: 3,
+	RIGHT_EAR: 4,
+	LEFT_SHOULDER: 5,
+	RIGHT_SHOULDER: 6,
+	LEFT_ELBOW: 7,
+	RIGHT_ELBOW: 8,
+	LEFT_WRIST: 9,
+	RIGHT_WRIST: 10,
+	LEFT_HIP: 11,
+	RIGHT_HIP: 12,
+	LEFT_KNEE: 13,
+	RIGHT_KNEE: 14,
+	LEFT_ANKLE: 15,
+	RIGHT_ANKLE: 16
+};
+const COCO17_KEYPOINT_NAMES = [
+	"nose",
+	"leftEye",
+	"rightEye",
+	"leftEar",
+	"rightEar",
+	"leftShoulder",
+	"rightShoulder",
+	"leftElbow",
+	"rightElbow",
+	"leftWrist",
+	"rightWrist",
+	"leftHip",
+	"rightHip",
+	"leftKnee",
+	"rightKnee",
+	"leftAnkle",
+	"rightAnkle"
+];
+/** COCO-17 skeleton bones for the WebGPU skeleton renderer (indices above). */
+const COCO17_BONES = [
+	{
+		from: COCO17_KEYPOINTS.NOSE,
+		to: COCO17_KEYPOINTS.LEFT_SHOULDER,
+		color: [
+			0,
+			1,
+			1,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.NOSE,
+		to: COCO17_KEYPOINTS.RIGHT_SHOULDER,
+		color: [
+			0,
+			1,
+			1,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.LEFT_SHOULDER,
+		to: COCO17_KEYPOINTS.RIGHT_SHOULDER,
+		color: [
+			1,
+			0,
+			0,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.LEFT_SHOULDER,
+		to: COCO17_KEYPOINTS.LEFT_ELBOW,
+		color: [
+			1,
+			.333,
+			0,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.LEFT_ELBOW,
+		to: COCO17_KEYPOINTS.LEFT_WRIST,
+		color: [
+			1,
+			.667,
+			0,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.RIGHT_SHOULDER,
+		to: COCO17_KEYPOINTS.RIGHT_ELBOW,
+		color: [
+			1,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.RIGHT_ELBOW,
+		to: COCO17_KEYPOINTS.RIGHT_WRIST,
+		color: [
+			.667,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.LEFT_SHOULDER,
+		to: COCO17_KEYPOINTS.LEFT_HIP,
+		color: [
+			.333,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.RIGHT_SHOULDER,
+		to: COCO17_KEYPOINTS.RIGHT_HIP,
+		color: [
+			0,
+			1,
+			0,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.LEFT_HIP,
+		to: COCO17_KEYPOINTS.RIGHT_HIP,
+		color: [
+			0,
+			1,
+			.333,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.LEFT_HIP,
+		to: COCO17_KEYPOINTS.LEFT_KNEE,
+		color: [
+			0,
+			1,
+			.667,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.LEFT_KNEE,
+		to: COCO17_KEYPOINTS.LEFT_ANKLE,
+		color: [
+			0,
+			1,
+			1,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.RIGHT_HIP,
+		to: COCO17_KEYPOINTS.RIGHT_KNEE,
+		color: [
+			0,
+			.667,
+			1,
+			1
+		]
+	},
+	{
+		from: COCO17_KEYPOINTS.RIGHT_KNEE,
+		to: COCO17_KEYPOINTS.RIGHT_ANKLE,
+		color: [
+			0,
+			.333,
+			1,
+			1
+		]
+	}
+];
+/**
+* WebGPU skeleton renderer for pose results.
+*
+* Rasterizes the primary person's COCO-17 keypoints into an OpenPose-style
+* conditioning texture natively in VRAM, using the COCO-17 bone set.
+*/
+var PoseSkeletonRenderer = class {
+	pipeline;
+	constructor(device) {
+		this.pipeline = new PoseSkeletonComputePipeline(device);
+	}
+	renderToTexture(keypoints, options, bones = COCO17_BONES) {
+		return this.pipeline.execute(keypoints, options, bones);
+	}
+	destroy() {
+		this.pipeline.destroy();
+	}
+};
+var SegmentationTexturePool = class {
+	device;
+	pool = /* @__PURE__ */ new Map();
+	constructor(device) {
+		this.device = device;
+	}
+	getOrCreateTexture(key, options) {
+		const existing = this.pool.get(key);
+		if (existing && existing.width === options.width && existing.height === options.height) return existing;
+		if (existing) existing.destroy();
+		const format = options.format ?? "rgba8unorm";
+		const texture = this.device.createTexture({
+			label: options.label ?? `vision_segmentation_${key}`,
+			size: [
+				options.width,
+				options.height,
+				1
+			],
+			format,
+			usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+		});
+		this.pool.set(key, texture);
+		return texture;
+	}
+	uploadMask(key, maskData, width, height) {
+		const isRgba = maskData.length >= width * height * 4;
+		const format = isRgba ? "rgba8unorm" : "r8unorm";
+		const texture = this.getOrCreateTexture(key, {
+			width,
+			height,
+			format
+		});
+		let uploadBytes;
+		if (maskData instanceof Float32Array) {
+			uploadBytes = new Uint8Array(maskData.length);
+			for (let i = 0; i < maskData.length; i++) uploadBytes[i] = Math.round(Math.max(0, Math.min(1, maskData[i])) * 255);
+		} else uploadBytes = maskData;
+		const bytesPerRow = width * (isRgba ? 4 : 1);
+		const alignedBytesPerRow = Math.ceil(bytesPerRow / 256) * 256;
+		let finalBuffer;
+		if (alignedBytesPerRow === bytesPerRow) finalBuffer = uploadBytes;
+		else {
+			finalBuffer = new Uint8Array(alignedBytesPerRow * height);
+			for (let y = 0; y < height; y++) finalBuffer.set(uploadBytes.subarray(y * bytesPerRow, (y + 1) * bytesPerRow), y * alignedBytesPerRow);
+		}
+		this.device.queue.writeTexture({ texture }, finalBuffer.buffer, {
+			offset: finalBuffer.byteOffset,
+			bytesPerRow: alignedBytesPerRow,
+			rowsPerImage: height
+		}, {
+			width,
+			height
+		});
+		return texture;
+	}
+	destroy() {
+		for (const tex of this.pool.values()) tex.destroy();
+		this.pool.clear();
+	}
+};
+/**
+* Resolves the default model cache directory:
+* 1. `FRAMEFIELDS_MODELS_DIR`
+* 2. `~/.cache/framefields/models`
+*/
+function getDefaultModelsDir() {
+	if (process.env.FRAMEFIELDS_MODELS_DIR) return resolve(process.env.FRAMEFIELDS_MODELS_DIR);
+	return resolve(homedir(), ".cache/framefields/models");
+}
+/**
+* Lazy model store. The constructor performs ZERO I/O; the only entry that can hit the
+* network is `ensure(key)`, called by an inference function the first time it runs.
+* Concurrent callers of the same key share a single in-flight download (promise dedupe),
+* downloads are written atomically (temp + rename), and verified files on disk are reused
+* across processes.
+*/
+var VisionModelStore = class {
+	_modelsDir;
+	_baseUrl;
+	_timeoutMs;
+	_retries;
+	_retryDelayMs;
+	_verify;
+	_fetch;
+	_onProgress;
+	_inflight = /* @__PURE__ */ new Map();
+	_buffers = /* @__PURE__ */ new Map();
+	_status = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this._modelsDir = options.modelsDir ? resolve(options.modelsDir) : getDefaultModelsDir();
+		this._baseUrl = options.baseUrl ?? process.env.FRAMEFIELDS_MODELS_BASE_URL ?? void 0;
+		this._timeoutMs = options.timeoutMs;
+		this._retries = Math.max(0, options.retries ?? 2);
+		this._retryDelayMs = options.retryDelayMs ?? 1e3;
+		this._verify = options.verify !== false;
+		this._fetch = options.fetchImpl ?? globalThis.fetch;
+		this._onProgress = options.onProgress;
+	}
+	get modelsDir() {
+		return this._modelsDir;
+	}
+	pathFor(key) {
+		return join(this._modelsDir, VISION_MODELS[key].filename);
+	}
+	descriptor(key) {
+		return VISION_MODELS[key];
+	}
+	/** The URL `ensure(key)` downloads from (mirror when `baseUrl` is set). */
+	urlFor(key) {
+		const desc = VISION_MODELS[key];
+		if (!this._baseUrl) return desc.url;
+		return `${this._baseUrl.replace(/\/+$/, "")}/${desc.filename}`;
+	}
+	/** True when a complete cached file exists (exact registry size when verifying). */
+	has(key) {
+		const targetPath = this.pathFor(key);
+		if (!existsSync(targetPath)) return false;
+		try {
+			const size = statSync(targetPath).size;
+			return this._verify ? size === VISION_MODELS[key].bytes : size > 0;
+		} catch {
+			return false;
+		}
+	}
+	/** Drops a cached model (file + memory) so the next `ensure` re-downloads it. */
+	async evict(key) {
+		this._buffers.delete(key);
+		this._status.set(key, "pending");
+		await unlink(this.pathFor(key)).catch(() => void 0);
+	}
+	status(key) {
+		return this._status.get(key) ?? "pending";
+	}
+	/** Snapshot of every tracked model's status (empty until anything is fetched). */
+	statuses() {
+		return new Map(this._status);
+	}
+	/** True when the model is resident in memory (loaded or downloaded this process). */
+	isLoaded(key) {
+		return this._buffers.has(key);
+	}
+	/**
+	* THE only download entry point. Returns the model bytes from memory (cached),
+	* loading from disk or fetching from the registry URL as needed.
+	*/
+	async ensure(key) {
+		const inMemory = this._buffers.get(key);
+		if (inMemory) return inMemory;
+		const inflight = this._inflight.get(key);
+		if (inflight) return inflight;
+		const promise = this.load(key).finally(() => this._inflight.delete(key));
+		this._inflight.set(key, promise);
+		return promise;
+	}
+	/** Explicit warm-up — fetch multiple models ahead of use (agents, renderers). */
+	async preload(keys) {
+		await Promise.all([...new Set(keys)].map((key) => this.ensure(key)));
+	}
+	async load(key) {
+		const targetPath = this.pathFor(key);
+		if (this.has(key)) {
+			this._status.set(key, "ready");
+			return this.readBuffer(key, targetPath);
+		}
+		const downloadUrl = this.urlFor(key);
+		this._status.set(key, "downloading");
+		if (!existsSync(dirname(targetPath))) mkdirSync(dirname(targetPath), { recursive: true });
+		const tempPath = `${targetPath}.tmp.${Date.now()}`;
+		try {
+			const { buffer, totalBytes } = await this.download(key, downloadUrl);
+			if (buffer.byteLength === 0) throw new Error(`Downloaded vision model '${key}' is empty (0 bytes).`);
+			if (this._verify) this.verifyBytes(key, buffer, downloadUrl);
+			this._onProgress?.(key, buffer.byteLength, totalBytes || buffer.byteLength);
+			await writeFile(tempPath, buffer);
+			await rename(tempPath, targetPath);
+			this._buffers.set(key, buffer);
+			this._status.set(key, "ready");
+			return buffer;
+		} catch (error) {
+			this._status.set(key, "error");
+			if (existsSync(tempPath)) await unlink(tempPath).catch(() => void 0);
+			throw error;
+		}
+	}
+	/** Fetches with retries on transient failures (network errors, HTTP 429/5xx). */
+	async download(key, url) {
+		for (let attempt = 0;; attempt++) {
+			let transient;
+			try {
+				const response = await this._fetch(url, { signal: this._timeoutMs ? AbortSignal.timeout(this._timeoutMs) : void 0 });
+				if (response.ok) {
+					const totalBytes = Number(response.headers.get("content-length") ?? 0);
+					return {
+						buffer: new Uint8Array(await response.arrayBuffer()),
+						totalBytes
+					};
+				}
+				const error = /* @__PURE__ */ new Error(`Failed to download vision model '${key}' from ${url}: HTTP ${response.status} ${response.statusText}`);
+				if (response.status !== 429 && response.status < 500) throw error;
+				transient = error;
+			} catch (error) {
+				if (!(error instanceof TypeError)) throw error;
+				transient = error;
+			}
+			if (attempt >= this._retries) throw new Error(`Failed to download vision model '${key}' from ${url} after ${attempt + 1} attempts: ${String(transient)}`, { cause: transient });
+			await new Promise((r) => setTimeout(r, this._retryDelayMs * 2 ** attempt));
+		}
+	}
+	verifyBytes(key, buffer, url) {
+		const desc = VISION_MODELS[key];
+		if (buffer.byteLength !== desc.bytes) throw new Error(`Vision model '${key}' from ${url} is ${buffer.byteLength} bytes, expected ${desc.bytes}.`);
+		const digest = createHash("sha256").update(buffer).digest("hex");
+		if (digest !== desc.sha256) throw new Error(`Vision model '${key}' from ${url} failed its SHA-256 check (got ${digest}, expected ${desc.sha256}).`);
+	}
+	async readBuffer(key, targetPath) {
+		const fileBuffer = await readFile(targetPath);
+		const buffer = new Uint8Array(fileBuffer.buffer, fileBuffer.byteOffset, fileBuffer.byteLength);
+		this._buffers.set(key, buffer);
+		return buffer;
+	}
+	/** Drops in-memory buffers (model stays on disk for the next run). */
+	clearMemoryCache() {
+		this._buffers.clear();
+	}
+};
+/** Neutral fallbacks so signal evaluators always have a well-formed frame to read. */
+function createNeutralObjectResult() {
+	return {
+		objects: [],
+		rawDetections: []
+	};
+}
+function createNeutralPoseResult() {
+	return { people: [] };
+}
+/** 17 neutral COCO keypoints at frame center — used by pose signals when nobody is detected. */
+function createNeutralLandmarks() {
+	const landmarks = [];
+	for (let i = 0; i < 17; i++) landmarks.push({
+		x: .5,
+		y: .5,
+		z: 0,
+		visibility: 0
+	});
+	return landmarks;
+}
+let defaultProvider;
+/** The provider for a runner created without one. */
+function createDefaultSessionProvider() {
+	return defaultProvider?.() ?? new NodeSessionProvider();
+}
+/** onnxruntime-node provider. The native module is imported lazily on first session. */
+var NodeSessionProvider = class {
+	kind = "node";
+	ortPromise;
+	async ort() {
+		if (!this.ortPromise) this.ortPromise = import("onnxruntime-node").catch((err) => {
+			this.ortPromise = void 0;
+			throw new Error(`onnxruntime-node failed to load (${String(err)}). Install it in the environment or provide a custom SessionProvider.`);
+		});
+		return this.ortPromise;
+	}
+	async createSession(modelBytes) {
+		const ort = await this.ort();
+		const session = await ort.InferenceSession.create(modelBytes, {
+			executionProviders: ["cpu"],
+			graphOptimizationLevel: "all"
+		});
+		return {
+			run: async (input) => {
+				const feeds = { [session.inputNames.includes(input.name) ? input.name : session.inputNames[0] ?? input.name]: new ort.Tensor("float32", input.data, [...input.dims]) };
+				const results = await session.run(feeds);
+				const outputs = {};
+				for (const [name, tensor] of Object.entries(results)) outputs[name] = {
+					data: tensor.data,
+					dims: [...tensor.dims]
+				};
+				return outputs;
+			},
+			release: () => {
+				session.release();
+			}
+		};
+	}
+};
+/**
+* Lazy vision runner.
+*
+* `create()` performs ZERO I/O: no downloads, no sessions. Each inference method downloads
+* its model and warms its session on FIRST USE ONLY, then reuses them for the process
+* lifetime. `detect()` and `segment()` share one RTMDet-Ins forward pass per frame.
+* Call `close()` to release sessions.
+*/
+var VisionRunner = class VisionRunner$1 {
+	variant;
+	confidence;
+	classes;
+	maskThreshold;
+	featherRadius;
+	_store;
+	_provider;
+	_sessions = /* @__PURE__ */ new Map();
+	_tensorScratch = /* @__PURE__ */ new Map();
+	/** One RTMDet-Ins pass per frame buffer, shared by detect() and segment(). */
+	_instancePass;
+	constructor(options) {
+		this.variant = options.variant ?? "s";
+		this.confidence = options.confidence ?? .3;
+		this.classes = options.classes;
+		this.maskThreshold = options.maskThreshold ?? .5;
+		this.featherRadius = options.featherRadius;
+		this._store = options.store ?? new VisionModelStore({
+			modelsDir: options.modelsDir,
+			baseUrl: options.baseUrl,
+			timeoutMs: options.timeoutMs,
+			onProgress: options.onProgress
+		});
+		this._provider = options.provider ?? createDefaultSessionProvider();
+	}
+	/** Cheap: no downloads, no sessions, no side effects. */
+	static create(options = {}) {
+		return new VisionRunner$1(options);
+	}
+	get modelsDir() {
+		return this._store.modelsDir;
+	}
+	/** Every registry model keyed to its current download state (downloaded → "ready"). */
+	get downloadStatus() {
+		const statuses = /* @__PURE__ */ new Map();
+		for (const key of Object.keys(VISION_MODELS)) statuses.set(key, "pending");
+		for (const [key, status] of this._store.statuses()) statuses.set(key, status);
+		return statuses;
+	}
+	/** The model serving `task` (matte depends on frame aspect; defaults to square). */
+	modelKeyFor(task, aspect = 1) {
+		return modelKeyFor(task, this.variant, aspect);
+	}
+	/**
+	* Explicit warm-up: downloads + sessions for the given tasks, ahead of first use.
+	* `matte` warms both aspect variants (the frame aspect is unknown until inference).
+	*/
+	async preload(tasks = ["detect"]) {
+		const keys = /* @__PURE__ */ new Set();
+		for (const task of tasks) if (task === "matte") {
+			keys.add("selfie-square");
+			keys.add("selfie-landscape");
+		} else keys.add(this.modelKeyFor(task));
+		await this._store.preload([...keys]);
+		await Promise.all([...keys].map((key) => this.session(key)));
+	}
+	/** COCO-80 boxes (sorted by score, source pixels). Masks are not decoded. */
+	async detect(image) {
+		const pass = await this.instancePass(image);
+		return decodeRtmdetIns({
+			...pass.outputs,
+			masks: void 0
+		}, this.instanceDecodeOptions(image, pass.transform)).detections;
+	}
+	/** COCO-80 boxes plus a frame-aligned soft mask per instance. */
+	async segment(image) {
+		const pass = await this.instancePass(image);
+		return decodeRtmdetIns(pass.outputs, this.instanceDecodeOptions(image, pass.transform));
+	}
+	/** COCO-17 keypoints per person (source pixels), highest score first. */
+	async pose(image) {
+		const key = this.modelKeyFor("pose");
+		const { outputs, transform } = await this.infer(key, image);
+		const dets = output(outputs, "dets", key);
+		const keypoints = output(outputs, "keypoints", key);
+		return decodeRtmo({
+			dets: dets.data,
+			keypoints: keypoints.data,
+			count: dets.dims[1] ?? 0,
+			keypointStride: keypoints.dims[3] ?? 3
+		}, {
+			confidence: this.confidence,
+			transform,
+			sourceWidth: image.width,
+			sourceHeight: image.height
+		});
+	}
+	/** Person-vs-background alpha for the whole frame (Selfie Segmenter). */
+	async matte(image) {
+		const key = this.modelKeyFor("matte", image.width / image.height);
+		const [w, h] = VISION_MODELS[key].input;
+		const { outputs } = await this.infer(key, image);
+		return decodeSelfie(output(outputs, "alphas", key).data, w, h, {
+			sourceWidth: image.width,
+			sourceHeight: image.height,
+			maskThreshold: this.maskThreshold,
+			...this.featherRadius !== void 0 ? { featherRadius: this.featherRadius } : {}
+		});
+	}
+	close() {
+		for (const promise of this._sessions.values()) promise.then((session) => session.release()).catch(() => void 0);
+		this._sessions.clear();
+		this._instancePass = void 0;
+		this._store.clearMemoryCache();
+	}
+	instancePass(image) {
+		if (this._instancePass?.frame === image.data) return this._instancePass.result;
+		const key = this.modelKeyFor("segment");
+		const result = this.infer(key, image).then(({ outputs, transform }) => {
+			const dets = output(outputs, "dets", key);
+			const masks = output(outputs, "masks", key);
+			return {
+				transform,
+				outputs: {
+					dets: dets.data,
+					labels: output(outputs, "labels", key).data,
+					masks: masks.data,
+					count: dets.dims[1] ?? 0,
+					maskHeight: masks.dims[masks.dims.length - 2] ?? 0,
+					maskWidth: masks.dims[masks.dims.length - 1] ?? 0
+				}
+			};
+		});
+		this._instancePass = {
+			frame: image.data,
+			result
+		};
+		result.catch(() => {
+			if (this._instancePass?.result === result) this._instancePass = void 0;
+		});
+		return result;
+	}
+	instanceDecodeOptions(image, transform) {
+		return {
+			confidence: this.confidence,
+			classes: this.classes,
+			classNames: COCO_CLASSES,
+			transform,
+			sourceWidth: image.width,
+			sourceHeight: image.height,
+			maskThreshold: this.maskThreshold,
+			...this.featherRadius !== void 0 ? { featherRadius: this.featherRadius } : {}
+		};
+	}
+	async infer(key, image) {
+		const session = await this.session(key);
+		const desc = VISION_MODELS[key];
+		const spec = preprocessSpec(desc.family, desc.input);
+		const size = 3 * spec.width * spec.height;
+		let scratch = this._tensorScratch.get(key);
+		if (!scratch || scratch.length < size) {
+			scratch = new Float32Array(size);
+			this._tensorScratch.set(key, scratch);
+		}
+		const { tensor, transform } = imageToTensor(image, spec, scratch);
+		return {
+			outputs: await session.run({
+				name: "input",
+				data: tensor,
+				dims: [
+					1,
+					3,
+					spec.height,
+					spec.width
+				]
+			}),
+			transform
+		};
+	}
+	session(key) {
+		let promise = this._sessions.get(key);
+		if (!promise) {
+			promise = this._store.ensure(key).then((bytes) => this._provider.createSession(bytes)).catch((err) => {
+				this._sessions.delete(key);
+				this._store.evict(key);
+				throw err;
+			});
+			this._sessions.set(key, promise);
+		}
+		return promise;
+	}
+};
+function output(outputs, name, key) {
+	const tensor = outputs[name];
+	if (!tensor) throw new Error(`Vision model '${key}' returned no '${name}' output (got: ${Object.keys(outputs).join(", ") || "none"}). Expected the ${VISION_MODELS[key].source}.`);
+	return tensor;
+}
+/**
+* The frame's primary instance: the largest person when present, else the most confident
+* instance (lowest `detectionIndex` — detections are score-sorted). Size alone is a poor
+* signal without a person: the largest instance is usually a backdrop ("dining table").
+*/
+function selectSubjectMask(masks) {
+	let best;
+	for (const m of masks) {
+		if (!best) {
+			best = m;
+			continue;
+		}
+		const mIsPerson = isPerson(m);
+		if (mIsPerson !== isPerson(best)) {
+			if (mIsPerson) best = m;
+		} else if (mIsPerson ? m.area > best.area : m.detectionIndex < best.detectionIndex) best = m;
+	}
+	return best;
+}
+function isPerson(mask) {
+	return mask.category.toLowerCase() === "person";
+}
+/** Tight pixel bounds of a mask's non-zero alpha, or null when empty. */
+function maskBounds(mask) {
+	const { mask: data, width, height } = mask;
+	let x0 = width;
+	let y0 = height;
+	let x1 = -1;
+	let y1 = -1;
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		for (let x = 0; x < width; x++) {
+			if (data[row + x] === 0) continue;
+			if (x < x0) x0 = x;
+			if (x > x1) x1 = x;
+			if (y < y0) y0 = y;
+			if (y > y1) y1 = y;
+		}
+	}
+	return x1 < 0 ? null : {
+		x0,
+		y0,
+		x1,
+		y1
+	};
+}
+/**
+* Builds the full subject silhouette: the primary instance plus every comparably sized
+* instance whose bounds sit mostly inside or across it (`overlap` = intersection / smaller
+* box area; `maxGrowth` caps a part's box area relative to the subject's).
+*
+* COCO has no "clothing" class, so a flowing dress, a held guitar or a ridden bike comes back
+* as its own instance (often mislabeled) — merging them keeps the whole figure in the cutout.
+* The size cap keeps containers out: a small figure inside a tunnel or window detected as a
+* huge "clock" must not drag the whole frame into the subject.
+*/
+function mergeSubjectMask(masks, overlap = .5, maxGrowth = 2) {
+	const subject = selectSubjectMask(masks);
+	if (!subject) return void 0;
+	const sb = maskBounds(subject);
+	if (!sb) return subject;
+	const subjectArea = boundsArea(sb);
+	const parts = masks.filter((m) => {
+		if (m === subject) return false;
+		const b = maskBounds(m);
+		return b !== null && boundsArea(b) <= subjectArea * maxGrowth && boundsOverlap(sb, b) >= overlap;
+	});
+	if (parts.length === 0) return subject;
+	const merged = subject.mask.slice();
+	for (const part of parts) {
+		const data = part.mask;
+		for (let i = 0; i < merged.length; i++) if (data[i] > merged[i]) merged[i] = data[i];
+	}
+	let area = 0;
+	for (let i = 0; i < merged.length; i++) area += merged[i];
+	area = Math.round(area / 255);
+	return {
+		...subject,
+		mask: merged,
+		area,
+		coverage: area / (subject.width * subject.height)
+	};
+}
+function boundsArea(b) {
+	return (b.x1 - b.x0 + 1) * (b.y1 - b.y0 + 1);
+}
+function boundsOverlap(a, b) {
+	const iw = Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0) + 1;
+	const ih = Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0) + 1;
+	if (iw <= 0 || ih <= 0) return 0;
+	return iw * ih / Math.min(boundsArea(a), boundsArea(b));
+}
+var SpatialLandmarkTransformer = class {
+	width;
+	height;
+	fovRad;
+	focalDistance;
+	constructor(camera) {
+		this.width = camera.width;
+		this.height = camera.height;
+		this.fovRad = (camera.fov ?? 60) * Math.PI / 180;
+		this.focalDistance = camera.cameraDistance ?? this.height / 2 / Math.tan(this.fovRad / 2);
+	}
+	/**
+	* Projects a normalized landmark [0, 1] into 2D/3D canvas coordinates.
+	*/
+	projectNormalizedLandmark(landmark, offsetZ = 0) {
+		const screenX = landmark.x * this.width;
+		const screenY = landmark.y * this.height;
+		const rawZ = landmark.z * this.width + offsetZ;
+		const effectiveZ = Math.min(rawZ, this.focalDistance - 10);
+		const scale = this.focalDistance / (this.focalDistance - effectiveZ);
+		return {
+			x: screenX,
+			y: screenY,
+			z: rawZ,
+			scale: Math.max(.1, scale)
+		};
+	}
+	/**
+	* Projects a metric world landmark [X_w, Y_w, Z_w] in meters into canvas space.
+	*/
+	projectWorldLandmark(worldLandmark, subjectDistanceMeters = 2, scaleMetersToPixels = 800) {
+		const centerX = this.width / 2;
+		const centerY = this.height / 2;
+		const worldX = worldLandmark.x * scaleMetersToPixels;
+		const worldY = worldLandmark.y * scaleMetersToPixels;
+		const worldZ = (worldLandmark.z + subjectDistanceMeters) * scaleMetersToPixels;
+		const effectiveZ = Math.min(worldZ, this.focalDistance - 10);
+		const scale = this.focalDistance / (this.focalDistance - effectiveZ);
+		return {
+			x: centerX + worldX * scale,
+			y: centerY + worldY * scale,
+			z: worldZ,
+			scale: Math.max(.1, scale)
+		};
+	}
+};
+function getPersonBoundingBox(person) {
+	if (person.boundingBox && person.boundingBox.width > 0 && person.boundingBox.height > 0) return {
+		originX: person.boundingBox.originX,
+		originY: person.boundingBox.originY,
+		width: person.boundingBox.width,
+		height: person.boundingBox.height
+	};
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	let validCount = 0;
+	for (const kp of person.keypoints) if (kp.visibility > .1) {
+		validCount++;
+		if (kp.x < minX) minX = kp.x;
+		if (kp.y < minY) minY = kp.y;
+		if (kp.x > maxX) maxX = kp.x;
+		if (kp.y > maxY) maxY = kp.y;
+	}
+	if (validCount === 0 || minX >= maxX || minY >= maxY) return {
+		originX: person.boundingBox?.originX ?? 0,
+		originY: person.boundingBox?.originY ?? 0,
+		width: person.boundingBox?.width ?? 0,
+		height: person.boundingBox?.height ?? 0
+	};
+	return {
+		originX: minX,
+		originY: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+/**
+* Matches detected pose people with active person tracks using greedy bipartite IoU.
+*
+* Annotates each person with the matched trackId.
+*/
+function matchPoseToTracks(people, trackedObjects, minIoU = .15) {
+	if (people.length === 0) return [];
+	const personTracks = trackedObjects.filter((o) => o.category.toLowerCase() === "person" && o.active);
+	if (personTracks.length === 0) return [...people];
+	const candidateMatches = [];
+	for (let p = 0; p < people.length; p++) {
+		const person = people[p];
+		if (person.trackId !== void 0) continue;
+		const pBox = getPersonBoundingBox(person);
+		const isNormalized = pBox.width <= 1.05 && pBox.height <= 1.05;
+		for (const trk of personTracks) {
+			const iou = computeIoU(pBox, isNormalized && trk.boundingBox.normalizedWidth > 0 ? {
+				originX: trk.boundingBox.normalizedX,
+				originY: trk.boundingBox.normalizedY,
+				width: trk.boundingBox.normalizedWidth,
+				height: trk.boundingBox.normalizedHeight
+			} : trk.boundingBox);
+			if (iou >= minIoU) candidateMatches.push({
+				personIdx: p,
+				trackId: trk.trackId,
+				iou
+			});
+		}
+	}
+	candidateMatches.sort((a, b) => b.iou - a.iou);
+	const assignedPeople = /* @__PURE__ */ new Set();
+	const assignedTracks = /* @__PURE__ */ new Set();
+	const personTrackMap = /* @__PURE__ */ new Map();
+	for (const match of candidateMatches) {
+		if (assignedPeople.has(match.personIdx) || assignedTracks.has(match.trackId)) continue;
+		assignedPeople.add(match.personIdx);
+		assignedTracks.add(match.trackId);
+		personTrackMap.set(match.personIdx, match.trackId);
+	}
+	if (people.length === 1 && personTracks.length === 1 && !personTrackMap.has(0) && people[0].trackId === void 0) personTrackMap.set(0, personTracks[0].trackId);
+	return people.map((person, idx) => {
+		if (person.trackId !== void 0) return person;
+		const trackId = personTrackMap.get(idx);
+		return trackId !== void 0 ? {
+			...person,
+			trackId
+		} : person;
+	});
+}
+var VisionBundle = class {
+	objects;
+	poseLandmarks;
+	masks;
+	segmentation;
+	classes;
+	poseLandmarksTensor;
+	objectsTensor;
+	masksTensor;
+	/** Per-class detection histogram [nc] — top-level convenience mirror of `classes.histogram`. */
+	histogramTensor;
+	_totalFrames;
+	_fps;
+	_width;
+	_height;
+	_transformer;
+	_stencilTexture;
+	_poseCache = /* @__PURE__ */ new Map();
+	_objectCache = /* @__PURE__ */ new Map();
+	_maskCache = /* @__PURE__ */ new Map();
+	_matteCache = /* @__PURE__ */ new Map();
+	_poseLmCache = /* @__PURE__ */ new Map();
+	_trackCache = /* @__PURE__ */ new Map();
+	_categoryCache = /* @__PURE__ */ new Map();
+	_classCache = /* @__PURE__ */ new Map();
+	_maskTrackCache = /* @__PURE__ */ new Map();
+	_registeredSignals = /* @__PURE__ */ new Set();
+	constructor(options = {}) {
+		this._totalFrames = options.totalFrames ?? 120;
+		this._fps = options.fps ?? 24;
+		this._width = options.width ?? 1920;
+		this._height = options.height ?? 1080;
+		this._transformer = new SpatialLandmarkTransformer({
+			width: this._width,
+			height: this._height,
+			fov: options.cameraFov ?? 60
+		});
+		const self = this;
+		const programmaticSignal$1 = (evaluator, sigOptions) => {
+			const sig = programmaticSignal(evaluator, sigOptions);
+			this._registeredSignals.add(sig);
+			return sig;
+		};
+		const getPrimaryLandmarks = (frame) => {
+			return this.getPoseResult(frame).people[0]?.keypoints ?? createNeutralLandmarks();
+		};
+		const createPoseCoord = (index, label) => {
+			const getLm = (frame) => getPrimaryLandmarks(frame)[index] ?? {
+				x: .5,
+				y: .5,
+				z: 0
+			};
+			return {
+				x: programmaticSignal$1((ctx) => getLm(ctx.frame).x, {
+					fps: this._fps,
+					label: `${label}_x`
+				}),
+				y: programmaticSignal$1((ctx) => getLm(ctx.frame).y, {
+					fps: this._fps,
+					label: `${label}_y`
+				}),
+				z: programmaticSignal$1((ctx) => getLm(ctx.frame).z ?? 0, {
+					fps: this._fps,
+					label: `${label}_z`
+				}),
+				screenX: programmaticSignal$1((ctx) => this._transformer.projectNormalizedLandmark(getLm(ctx.frame)).x, {
+					fps: this._fps,
+					label: `${label}_screenX`
+				}),
+				screenY: programmaticSignal$1((ctx) => this._transformer.projectNormalizedLandmark(getLm(ctx.frame)).y, {
+					fps: this._fps,
+					label: `${label}_screenY`
+				})
+			};
+		};
+		const getOrCreatePoseLm = (index) => {
+			let sig = this._poseLmCache.get(index);
+			if (!sig) {
+				sig = createPoseCoord(index, COCO17_KEYPOINT_NAMES[index] ?? `kpt_${index}`);
+				this._poseLmCache.set(index, sig);
+			}
+			return sig;
+		};
+		const poseNamed = {
+			nose: getOrCreatePoseLm(COCO17_KEYPOINTS.NOSE),
+			leftEye: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_EYE),
+			rightEye: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_EYE),
+			leftEar: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_EAR),
+			rightEar: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_EAR),
+			shoulder: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_SHOULDER),
+			leftShoulder: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_SHOULDER),
+			rightShoulder: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_SHOULDER),
+			leftElbow: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_ELBOW),
+			rightElbow: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_ELBOW),
+			leftWrist: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_WRIST),
+			rightWrist: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_WRIST),
+			leftHip: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_HIP),
+			rightHip: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_HIP),
+			leftKnee: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_KNEE),
+			rightKnee: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_KNEE),
+			leftAnkle: getOrCreatePoseLm(COCO17_KEYPOINTS.LEFT_ANKLE),
+			rightAnkle: getOrCreatePoseLm(COCO17_KEYPOINTS.RIGHT_ANKLE),
+			get: getOrCreatePoseLm
+		};
+		this.poseLandmarks = new Proxy(poseNamed, { get(target, prop, receiver) {
+			if (typeof prop === "string" && /^\d+$/.test(prop)) return target.get(Number(prop));
+			if (typeof prop === "number") return target.get(prop);
+			return Reflect.get(target, prop, receiver);
+		} });
+		const neutralTrack = (trackId, category = "unknown") => ({
+			trackId,
+			category,
+			score: 0,
+			boundingBox: {
+				originX: this._width / 2,
+				originY: this._height / 2,
+				width: 0,
+				height: 0,
+				normalizedX: .5,
+				normalizedY: .5,
+				normalizedWidth: 0,
+				normalizedHeight: 0
+			},
+			centerX: this._width / 2,
+			centerY: this._height / 2,
+			normalizedCenterX: .5,
+			normalizedCenterY: .5,
+			velocity: {
+				vx: 0,
+				vy: 0
+			},
+			speed: 0,
+			age: 0,
+			hits: 0,
+			active: false,
+			isCoasting: false
+		});
+		const createAnchor = (getPos, label) => {
+			const screenX = programmaticSignal$1((ctx) => getPos(ctx.frame).sx, {
+				fps: this._fps,
+				label: `${label}_screenX`
+			});
+			const screenY = programmaticSignal$1((ctx) => getPos(ctx.frame).sy, {
+				fps: this._fps,
+				label: `${label}_screenY`
+			});
+			return {
+				x: programmaticSignal$1((ctx) => this._width > 0 ? getPos(ctx.frame).sx / this._width : 0, {
+					fps: this._fps,
+					label: `${label}_x`
+				}),
+				y: programmaticSignal$1((ctx) => this._height > 0 ? getPos(ctx.frame).sy / this._height : 0, {
+					fps: this._fps,
+					label: `${label}_y`
+				}),
+				z: programmaticSignal$1(() => 0, {
+					fps: this._fps,
+					label: `${label}_z`
+				}),
+				screenX,
+				screenY
+			};
+		};
+		const buildTrackPoseSignals = (resolveTrack, label, fixedId) => {
+			const resolvePerson = (frame) => {
+				const poseRes = self.getPoseResult(frame);
+				if (poseRes.people.length === 0) return void 0;
+				const trk = resolveTrack(frame);
+				const targetId = fixedId ?? trk.trackId;
+				const byId = poseRes.people.find((p) => p.trackId === targetId);
+				if (byId) return byId;
+				if (!trk.active && poseRes.people.length > 1) return void 0;
+				if (poseRes.people.length === 1) return poseRes.people[0];
+				let bestPerson;
+				let bestIoU = .1;
+				for (const p of poseRes.people) {
+					const pBox = getPersonBoundingBox(p);
+					const iou = computeIoU(pBox, pBox.width <= 1.05 && pBox.height <= 1.05 && trk.boundingBox.normalizedWidth > 0 ? {
+						originX: trk.boundingBox.normalizedX,
+						originY: trk.boundingBox.normalizedY,
+						width: trk.boundingBox.normalizedWidth,
+						height: trk.boundingBox.normalizedHeight
+					} : trk.boundingBox);
+					if (iou > bestIoU) {
+						bestIoU = iou;
+						bestPerson = p;
+					}
+				}
+				return bestPerson;
+			};
+			const hasPose = programmaticSignal$1((ctx) => resolvePerson(ctx.frame) ? 1 : 0, {
+				fps: this._fps,
+				label: `${label}_hasPose`
+			});
+			const createCoord = (index, kptName) => {
+				const getLm = (frame) => {
+					const kp = resolvePerson(frame)?.keypoints[index];
+					if (kp && kp.visibility > .05) return {
+						x: kp.x,
+						y: kp.y,
+						z: 0
+					};
+					const trk = resolveTrack(frame);
+					return {
+						x: trk.normalizedCenterX,
+						y: trk.normalizedCenterY,
+						z: 0
+					};
+				};
+				return {
+					x: programmaticSignal$1((ctx) => getLm(ctx.frame).x, {
+						fps: this._fps,
+						label: `${label}_${kptName}_x`
+					}),
+					y: programmaticSignal$1((ctx) => getLm(ctx.frame).y, {
+						fps: this._fps,
+						label: `${label}_${kptName}_y`
+					}),
+					z: programmaticSignal$1((ctx) => getLm(ctx.frame).z ?? 0, {
+						fps: this._fps,
+						label: `${label}_${kptName}_z`
+					}),
+					screenX: programmaticSignal$1((ctx) => self._transformer.projectNormalizedLandmark(getLm(ctx.frame)).x, {
+						fps: this._fps,
+						label: `${label}_${kptName}_screenX`
+					}),
+					screenY: programmaticSignal$1((ctx) => self._transformer.projectNormalizedLandmark(getLm(ctx.frame)).y, {
+						fps: this._fps,
+						label: `${label}_${kptName}_screenY`
+					})
+				};
+			};
+			const coordsCache = /* @__PURE__ */ new Map();
+			const getOrCreateCoord = (idx) => {
+				let c = coordsCache.get(idx);
+				if (!c) {
+					c = createCoord(idx, COCO17_KEYPOINT_NAMES[idx] ?? `kpt_${idx}`);
+					coordsCache.set(idx, c);
+				}
+				return c;
+			};
+			const namedPose = {
+				hasPose,
+				wristSpeed: programmaticSignal$1((ctx) => {
+					const f = ctx.frame;
+					const curr = resolvePerson(f);
+					if (!curr) return 0;
+					const prev = resolvePerson(Math.max(0, f - 1));
+					const currKp = curr.keypoints;
+					const prevKp = prev?.keypoints;
+					const rwCurr = currKp[COCO17_KEYPOINTS.RIGHT_WRIST];
+					const rwPrev = prevKp?.[COCO17_KEYPOINTS.RIGHT_WRIST];
+					let rwSpeed = 0;
+					if (rwCurr && rwPrev && rwCurr.visibility > .1 && rwPrev.visibility > .1) {
+						const dx = (rwCurr.x - rwPrev.x) * this._width;
+						const dy = (rwCurr.y - rwPrev.y) * this._height;
+						rwSpeed = Math.sqrt(dx * dx + dy * dy) * this._fps;
+					}
+					const lwCurr = currKp[COCO17_KEYPOINTS.LEFT_WRIST];
+					const lwPrev = prevKp?.[COCO17_KEYPOINTS.LEFT_WRIST];
+					let lwSpeed = 0;
+					if (lwCurr && lwPrev && lwCurr.visibility > .1 && lwPrev.visibility > .1) {
+						const dx = (lwCurr.x - lwPrev.x) * this._width;
+						const dy = (lwCurr.y - lwPrev.y) * this._height;
+						lwSpeed = Math.sqrt(dx * dx + dy * dy) * this._fps;
+					}
+					return Math.max(rwSpeed, lwSpeed);
+				}, {
+					fps: this._fps,
+					label: `${label}_wristSpeed`
+				}),
+				handRaised: programmaticSignal$1((ctx) => {
+					const p = resolvePerson(ctx.frame);
+					if (!p) return 0;
+					const k = p.keypoints;
+					const lw = k[COCO17_KEYPOINTS.LEFT_WRIST];
+					const ls = k[COCO17_KEYPOINTS.LEFT_SHOULDER];
+					const rw = k[COCO17_KEYPOINTS.RIGHT_WRIST];
+					const rs = k[COCO17_KEYPOINTS.RIGHT_SHOULDER];
+					const lRaised = lw && ls && lw.visibility > .1 && ls.visibility > .1 && lw.y < ls.y;
+					const rRaised = rw && rs && rw.visibility > .1 && rs.visibility > .1 && rw.y < rs.y;
+					return lRaised || rRaised ? 1 : 0;
+				}, {
+					fps: this._fps,
+					label: `${label}_handRaised`
+				}),
+				bodyTiltAngle: programmaticSignal$1((ctx) => {
+					const p = resolvePerson(ctx.frame);
+					if (!p) return 0;
+					const k = p.keypoints;
+					const ls = k[COCO17_KEYPOINTS.LEFT_SHOULDER];
+					const rs = k[COCO17_KEYPOINTS.RIGHT_SHOULDER];
+					const lh = k[COCO17_KEYPOINTS.LEFT_HIP];
+					const rh = k[COCO17_KEYPOINTS.RIGHT_HIP];
+					if (!ls || !rs || !lh || !rh) return 0;
+					const sx = (ls.x + rs.x) / 2 * this._width;
+					const sy = (ls.y + rs.y) / 2 * this._height;
+					const hx = (lh.x + rh.x) / 2 * this._width;
+					const hy = (lh.y + rh.y) / 2 * this._height;
+					const dx = sx - hx;
+					const dy = sy - hy;
+					if (dx === 0 && dy === 0) return 0;
+					return Math.atan2(dx, -dy);
+				}, {
+					fps: this._fps,
+					label: `${label}_bodyTiltAngle`
+				}),
+				nose: getOrCreateCoord(COCO17_KEYPOINTS.NOSE),
+				leftEye: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_EYE),
+				rightEye: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_EYE),
+				leftEar: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_EAR),
+				rightEar: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_EAR),
+				shoulder: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_SHOULDER),
+				leftShoulder: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_SHOULDER),
+				rightShoulder: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_SHOULDER),
+				leftElbow: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_ELBOW),
+				rightElbow: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_ELBOW),
+				leftWrist: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_WRIST),
+				rightWrist: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_WRIST),
+				leftHip: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_HIP),
+				rightHip: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_HIP),
+				leftKnee: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_KNEE),
+				rightKnee: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_KNEE),
+				leftAnkle: getOrCreateCoord(COCO17_KEYPOINTS.LEFT_ANKLE),
+				rightAnkle: getOrCreateCoord(COCO17_KEYPOINTS.RIGHT_ANKLE),
+				get: getOrCreateCoord
+			};
+			return new Proxy(namedPose, { get(target, prop, receiver) {
+				if (typeof prop === "string" && /^\d+$/.test(prop)) return target.get(Number(prop));
+				if (typeof prop === "number") return target.get(prop);
+				return Reflect.get(target, prop, receiver);
+			} });
+		};
+		const buildTrackSignals = (resolve$1, label, fixedCategory, fixedId) => {
+			const getBox = (f) => resolve$1(f).boundingBox;
+			const pose = buildTrackPoseSignals(resolve$1, `${label}_pose`, fixedId);
+			const anchor = (name, sx, sy) => createAnchor((f) => ({
+				sx: sx(getBox(f)),
+				sy: sy(getBox(f))
+			}), `${label}_${name}`);
+			const center = anchor("center", (b) => b.originX + b.width / 2, (b) => b.originY + b.height / 2);
+			const speed = programmaticSignal$1((ctx) => resolve$1(ctx.frame).speed, {
+				fps: this._fps,
+				label: `${label}_speed`
+			});
+			return {
+				get trackId() {
+					return fixedId ?? resolve$1(0).trackId;
+				},
+				get category() {
+					return fixedCategory ?? resolve$1(0).category;
+				},
+				bounds: {
+					x: programmaticSignal$1((ctx) => getBox(ctx.frame).normalizedX, {
+						fps: this._fps,
+						label: `${label}_normX`
+					}),
+					y: programmaticSignal$1((ctx) => getBox(ctx.frame).normalizedY, {
+						fps: this._fps,
+						label: `${label}_normY`
+					}),
+					width: programmaticSignal$1((ctx) => getBox(ctx.frame).normalizedWidth, {
+						fps: this._fps,
+						label: `${label}_normWidth`
+					}),
+					height: programmaticSignal$1((ctx) => getBox(ctx.frame).normalizedHeight, {
+						fps: this._fps,
+						label: `${label}_normHeight`
+					}),
+					screenX: programmaticSignal$1((ctx) => getBox(ctx.frame).originX, {
+						fps: this._fps,
+						label: `${label}_screenX`
+					}),
+					screenY: programmaticSignal$1((ctx) => getBox(ctx.frame).originY, {
+						fps: this._fps,
+						label: `${label}_screenY`
+					}),
+					screenWidth: programmaticSignal$1((ctx) => getBox(ctx.frame).width, {
+						fps: this._fps,
+						label: `${label}_screenWidth`
+					}),
+					screenHeight: programmaticSignal$1((ctx) => getBox(ctx.frame).height, {
+						fps: this._fps,
+						label: `${label}_screenHeight`
+					}),
+					aspectRatio: programmaticSignal$1((ctx) => {
+						const b = getBox(ctx.frame);
+						return b.height > 0 ? b.width / b.height : 1;
+					}, {
+						fps: this._fps,
+						label: `${label}_aspectRatio`
+					}),
+					area: programmaticSignal$1((ctx) => {
+						const b = getBox(ctx.frame);
+						return b.width * b.height;
+					}, {
+						fps: this._fps,
+						label: `${label}_area`
+					})
+				},
+				anchors: {
+					topLeft: anchor("topLeft", (b) => b.originX, (b) => b.originY),
+					topCenter: anchor("topCenter", (b) => b.originX + b.width / 2, (b) => b.originY),
+					topRight: anchor("topRight", (b) => b.originX + b.width, (b) => b.originY),
+					centerLeft: anchor("centerLeft", (b) => b.originX, (b) => b.originY + b.height / 2),
+					center,
+					centerRight: anchor("centerRight", (b) => b.originX + b.width, (b) => b.originY + b.height / 2),
+					bottomLeft: anchor("bottomLeft", (b) => b.originX, (b) => b.originY + b.height),
+					bottomCenter: anchor("bottomCenter", (b) => b.originX + b.width / 2, (b) => b.originY + b.height),
+					bottomRight: anchor("bottomRight", (b) => b.originX + b.width, (b) => b.originY + b.height)
+				},
+				kinematics: {
+					vx: programmaticSignal$1((ctx) => resolve$1(ctx.frame).velocity.vx, {
+						fps: this._fps,
+						label: `${label}_vx`
+					}),
+					vy: programmaticSignal$1((ctx) => resolve$1(ctx.frame).velocity.vy, {
+						fps: this._fps,
+						label: `${label}_vy`
+					}),
+					speed,
+					acceleration: speed.velocity(1),
+					headingRad: programmaticSignal$1((ctx) => {
+						const v = resolve$1(ctx.frame).velocity;
+						return Math.atan2(v.vy, v.vx);
+					}, {
+						fps: this._fps,
+						label: `${label}_headingRad`
+					}),
+					headingDeg: programmaticSignal$1((ctx) => {
+						const v = resolve$1(ctx.frame).velocity;
+						return Math.atan2(v.vy, v.vx) * 180 / Math.PI;
+					}, {
+						fps: this._fps,
+						label: `${label}_headingDeg`
+					})
+				},
+				confidence: programmaticSignal$1((ctx) => resolve$1(ctx.frame).score, {
+					fps: this._fps,
+					label: `${label}_score`
+				}),
+				active: programmaticSignal$1((ctx) => resolve$1(ctx.frame).active ? 1 : 0, {
+					fps: this._fps,
+					label: `${label}_active`
+				}),
+				isCoasting: programmaticSignal$1((ctx) => resolve$1(ctx.frame).isCoasting ? 1 : 0, {
+					fps: this._fps,
+					label: `${label}_isCoasting`
+				}),
+				age: programmaticSignal$1((ctx) => resolve$1(ctx.frame).age, {
+					fps: this._fps,
+					label: `${label}_age`
+				}),
+				pose,
+				center,
+				topCenter: this[`__pending`],
+				bottomCenter: center,
+				topLeft: center,
+				bottomLeft: center
+			};
+		};
+		const buildTrack = (resolve$1, label, fixedCategory, fixedId) => {
+			const sig = buildTrackSignals(resolve$1, label, fixedCategory, fixedId);
+			const anchors = sig.anchors;
+			Object.assign(sig, {
+				topCenter: anchors.topCenter,
+				bottomCenter: anchors.bottomCenter,
+				topLeft: anchors.topLeft,
+				bottomLeft: anchors.bottomLeft
+			});
+			return sig;
+		};
+		const getTrackById = (trackId) => {
+			let sig = this._trackCache.get(trackId);
+			if (!sig) {
+				sig = buildTrack((frame) => this.getObjectResult(frame).objects.find((o) => o.trackId === trackId) ?? neutralTrack(trackId), `track_${trackId}`, void 0, trackId);
+				this._trackCache.set(trackId, sig);
+			}
+			return sig;
+		};
+		const getTrackByCategory = (category, rank = 0) => {
+			const cacheKey = `${category.toLowerCase()}_${rank}`;
+			let sig = this._categoryCache.get(cacheKey);
+			if (!sig) {
+				sig = buildTrack((frame) => {
+					return this.getObjectResult(frame).objects.filter((o) => o.category.toLowerCase() === category.toLowerCase() && o.active)[rank] ?? neutralTrack(0, category);
+				}, `cat_${category}_${rank}`, category);
+				this._categoryCache.set(cacheKey, sig);
+			}
+			return sig;
+		};
+		const primaryTrack = buildTrack((frame) => {
+			const res = this.getObjectResult(frame);
+			if (res.objects.length === 0) return neutralTrack(0);
+			let best = res.objects[0];
+			for (let i = 1; i < res.objects.length; i++) if (res.objects[i].score > best.score) best = res.objects[i];
+			return best;
+		}, "primary_object");
+		const activeCategories = (frame) => {
+			const set = /* @__PURE__ */ new Set();
+			for (const o of this.getObjectResult(frame).objects) if (o.active) set.add(o.category);
+			return Array.from(set).sort();
+		};
+		const buildClassSignals = (category) => {
+			const lower = category.toLowerCase();
+			let sig = this._classCache.get(lower);
+			if (sig) return sig;
+			sig = {
+				count: programmaticSignal$1((ctx) => this.getObjectResult(ctx.frame).objects.filter((o) => o.active && o.category.toLowerCase() === lower).length, {
+					fps: this._fps,
+					label: `class_${lower}_count`
+				}),
+				maxConfidence: programmaticSignal$1((ctx) => {
+					let max = 0;
+					for (const o of this.getObjectResult(ctx.frame).objects) if (o.active && o.category.toLowerCase() === lower && o.score > max) max = o.score;
+					return max;
+				}, {
+					fps: this._fps,
+					label: `class_${lower}_maxConf`
+				}),
+				present: programmaticSignal$1((ctx) => this.getObjectResult(ctx.frame).objects.some((o) => o.active && o.category.toLowerCase() === lower) ? 1 : 0, {
+					fps: this._fps,
+					label: `class_${lower}_present`
+				}),
+				primary: getTrackByCategory(category)
+			};
+			this._classCache.set(lower, sig);
+			return sig;
+		};
+		this.classes = {
+			get: buildClassSignals,
+			get names() {
+				return activeCategories(frameSignal.value);
+			},
+			histogram: {
+				get: (ctx) => self.getClassHistogramTensor(ctx?.frame ?? frameSignal.value),
+				get value() {
+					return self.getClassHistogramTensor(frameSignal.value);
+				}
+			}
+		};
+		this.objects = {
+			get: getTrackById,
+			byCategory: getTrackByCategory,
+			primary: primaryTrack,
+			count: programmaticSignal$1((ctx) => this.getObjectResult(ctx.frame).objects.filter((o) => o.active).length, {
+				fps: this._fps,
+				label: "tracked_objects_count"
+			}),
+			hasCategory: (category) => buildClassSignals(category).present,
+			getActiveTracks: (frame) => this.getObjectResult(frame).objects.filter((o) => o.active),
+			get detectedCategories() {
+				return activeCategories(frameSignal.value);
+			}
+		};
+		const maskForTrack = (frame, trackId) => this.getMaskResult(frame).find((m) => m.trackId === trackId);
+		const subjectMask = (frame) => selectSubjectMask(this.getMaskResult(frame));
+		const buildMaskTrackSignals = (resolve$1, label) => {
+			const boxFor = (frame) => {
+				const mask = resolve$1(frame);
+				if (!mask || mask.trackId === void 0) return void 0;
+				return this.getObjectResult(frame).objects.find((o) => o.trackId === mask.trackId);
+			};
+			return {
+				get trackId() {
+					return resolve$1(frameSignal.value)?.trackId ?? 0;
+				},
+				get category() {
+					return resolve$1(frameSignal.value)?.category ?? "unknown";
+				},
+				area: programmaticSignal$1((ctx) => resolve$1(ctx.frame)?.area ?? 0, {
+					fps: this._fps,
+					label: `${label}_area`
+				}),
+				coverage: programmaticSignal$1((ctx) => resolve$1(ctx.frame)?.coverage ?? 0, {
+					fps: this._fps,
+					label: `${label}_coverage`
+				}),
+				solidity: programmaticSignal$1((ctx) => {
+					const mask = resolve$1(ctx.frame);
+					const box = boxFor(ctx.frame);
+					if (!mask || !box) return 0;
+					const bboxArea = box.boundingBox.width * box.boundingBox.height;
+					return bboxArea > 0 ? mask.area / bboxArea : 0;
+				}, {
+					fps: this._fps,
+					label: `${label}_solidity`
+				}),
+				bboxFill: programmaticSignal$1((ctx) => {
+					const mask = resolve$1(ctx.frame);
+					if (!mask || mask.width * mask.height === 0) return 0;
+					const box = boxFor(ctx.frame);
+					if (!box) return 0;
+					return box.boundingBox.width * box.boundingBox.height / (mask.width * mask.height);
+				}, {
+					fps: this._fps,
+					label: `${label}_bboxFill`
+				})
+			};
+		};
+		this.masks = {
+			get: (trackId) => {
+				let sig = this._maskTrackCache.get(trackId);
+				if (!sig) {
+					sig = buildMaskTrackSignals((frame) => maskForTrack(frame, trackId), `mask_${trackId}`);
+					this._maskTrackCache.set(trackId, sig);
+				}
+				return sig;
+			},
+			subject: buildMaskTrackSignals(subjectMask, "subject"),
+			count: programmaticSignal$1((ctx) => new Set(this.getMaskResult(ctx.frame).map((m) => m.trackId ?? -1)).size, {
+				fps: this._fps,
+				label: "mask_count"
+			})
+		};
+		this.segmentation = {
+			humanSilhouette: this.masks.subject,
+			subject: this.masks.subject,
+			instanceMasks: this.masks,
+			matte: {
+				coverage: programmaticSignal$1((ctx) => self.getMatteResult(ctx.frame)?.coverage ?? 0, {
+					fps: this._fps,
+					label: "matte_coverage"
+				}),
+				at: (frame) => self.getMatteResult(frame)
+			},
+			get stencilTexture() {
+				return self._stencilTexture;
+			}
+		};
+		this.poseLandmarksTensor = {
+			get: (ctx) => self.getPoseLandmarksTensor(ctx?.frame ?? frameSignal.value),
+			get value() {
+				return self.getPoseLandmarksTensor(frameSignal.value);
+			}
+		};
+		this.objectsTensor = {
+			get: (ctx) => self.getObjectsTensor(ctx?.frame ?? frameSignal.value),
+			get value() {
+				return self.getObjectsTensor(frameSignal.value);
+			}
+		};
+		this.masksTensor = {
+			get: (ctx) => self.getMasksTensor(ctx?.frame ?? frameSignal.value),
+			get value() {
+				return self.getMasksTensor(frameSignal.value);
+			}
+		};
+		this.histogramTensor = {
+			get: (ctx) => self.getClassHistogramTensor(ctx?.frame ?? frameSignal.value),
+			get value() {
+				return self.getClassHistogramTensor(frameSignal.value);
+			}
+		};
+	}
+	setStencilTexture(texture) {
+		this._stencilTexture = texture;
+	}
+	get stencilTexture() {
+		return this._stencilTexture;
+	}
+	/**
+	* Reads the most recent result at or before `frame`. Vision results are written one
+	* frame behind the plate (the node renderer reads back the previous frame to infer),
+	* and pinned-signal layout runs before the current frame's inference, so a strict
+	* per-frame lookup would always miss. Walking back a few frames keeps signals live at
+	* a stable one-frame lag instead of snapping to neutral defaults.
+	*/
+	latestAtOrBefore(cache, frame, maxBack = 8) {
+		const start = this.clamp(frame);
+		const floor = Math.max(0, start - maxBack);
+		for (let f = start; f >= floor; f--) {
+			const value = cache.get(f);
+			if (value !== void 0) return value;
+		}
+	}
+	invalidateSignals() {
+		for (const sig of this._registeredSignals) sig.invalidate();
+	}
+	setPoseResult(frame, result) {
+		this._poseCache.set(this.clamp(frame), result);
+		this.invalidateSignals();
+	}
+	getPoseResult(frame) {
+		return this.latestAtOrBefore(this._poseCache, frame) ?? createNeutralPoseResult();
+	}
+	setObjectResult(frame, result) {
+		const normalized = "objects" in result ? result : {
+			objects: result,
+			rawDetections: []
+		};
+		this._objectCache.set(this.clamp(frame), {
+			objects: normalized.objects,
+			rawDetections: normalized.rawDetections ?? []
+		});
+		this.invalidateSignals();
+	}
+	getObjectResult(frame) {
+		return this.latestAtOrBefore(this._objectCache, frame) ?? createNeutralObjectResult();
+	}
+	setMaskResult(frame, masks) {
+		this._maskCache.set(this.clamp(frame), masks);
+		this.invalidateSignals();
+	}
+	getMaskResult(frame) {
+		return this.latestAtOrBefore(this._maskCache, frame) ?? [];
+	}
+	setMatteResult(frame, matte) {
+		this._matteCache.set(this.clamp(frame), matte);
+		this.invalidateSignals();
+	}
+	getMatteResult(frame) {
+		return this.latestAtOrBefore(this._matteCache, frame);
+	}
+	/**
+	* Serializable snapshot of one frame's object / class / mask signals.
+	* Synchronous — reads only the per-frame caches, never triggers inference.
+	*/
+	summary(frame = frameSignal.value) {
+		const f = this.clamp(frame);
+		const res = this.getObjectResult(f);
+		const objects = res.objects.map((o) => ({
+			trackId: o.trackId,
+			category: o.category,
+			score: o.score,
+			center: [o.centerX, o.centerY],
+			speed: o.speed,
+			active: o.active
+		}));
+		const classSet = /* @__PURE__ */ new Set();
+		for (const o of res.objects) if (o.active) classSet.add(o.category);
+		const masks = {};
+		for (const m of this.getMaskResult(f)) masks[m.category] = (masks[m.category] ?? 0) + 1;
+		return {
+			frame: f,
+			objects,
+			classes: Array.from(classSet).sort(),
+			masks
+		};
+	}
+	/** Primary person's 17 keypoints as a [17, 3] float32 tensor. */
+	getPoseLandmarksTensor(frame) {
+		const kpts = this.getPoseResult(frame).people[0]?.keypoints ?? [];
+		const data = new Float32Array(51);
+		for (let i = 0; i < 17; i++) {
+			data[i * 3] = kpts[i]?.x ?? .5;
+			data[i * 3 + 1] = kpts[i]?.y ?? .5;
+			data[i * 3 + 2] = kpts[i]?.visibility ?? 0;
+		}
+		return {
+			data,
+			shape: [17, 3],
+			dtype: "float32"
+		};
+	}
+	/** Up to 16 active tracks as [16, 8]: [active, categoryHash, x, y, w, h, vx, vy]. */
+	getObjectsTensor(frame, maxObjects = 16) {
+		const res = this.getObjectResult(frame);
+		const data = new Float32Array(maxObjects * 8);
+		const count = Math.min(maxObjects, res.objects.length);
+		for (let i = 0; i < count; i++) {
+			const obj = res.objects[i];
+			const off = i * 8;
+			let catHash = 0;
+			for (let c = 0; c < obj.category.length; c++) catHash = catHash * 31 + obj.category.charCodeAt(c) & 65535;
+			data[off] = obj.active ? 1 : 0;
+			data[off + 1] = catHash;
+			data[off + 2] = obj.centerX;
+			data[off + 3] = obj.centerY;
+			data[off + 4] = obj.boundingBox.width;
+			data[off + 5] = obj.boundingBox.height;
+			data[off + 6] = obj.velocity.vx;
+			data[off + 7] = obj.velocity.vy;
+		}
+		return {
+			data,
+			shape: [maxObjects, 8],
+			dtype: "float32"
+		};
+	}
+	/** Per-mask coverage + solidity as [16, 2]. */
+	getMasksTensor(frame, maxMasks = 16) {
+		const masks = this.getMaskResult(frame);
+		const data = new Float32Array(maxMasks * 2);
+		const count = Math.min(maxMasks, masks.length);
+		for (let i = 0; i < count; i++) {
+			const m = masks[i];
+			data[i * 2] = m.coverage;
+			const box = this.getObjectResult(frame).objects.find((o) => o.trackId === m.trackId);
+			const bboxArea = box ? box.boundingBox.width * box.boundingBox.height : 0;
+			data[i * 2 + 1] = bboxArea > 0 ? m.area / bboxArea : 0;
+		}
+		return {
+			data,
+			shape: [maxMasks, 2],
+			dtype: "float32"
+		};
+	}
+	/** Per-class detection histogram for the frame as [nc] float32 (COCO 80 by default). */
+	getClassHistogramTensor(frame, nc = 80) {
+		const data = new Float32Array(nc);
+		for (const o of this.getObjectResult(frame).objects) if (o.active) {
+			const idx = COCO_CLASS_INDEX_BY_NAME.get(o.category.toLowerCase());
+			if (idx !== void 0) data[idx] += 1;
+		}
+		return {
+			data,
+			shape: [nc],
+			dtype: "float32"
+		};
+	}
+	clamp(frame) {
+		return Math.max(0, Math.min(this._totalFrames - 1, Math.round(frame)));
+	}
+};
+const COCO_CLASS_INDEX_BY_NAME = new Map(COCO_CLASSES.map((name, index) => [name, index]));
+function pinNodeToLandmark(node, target, options = {}) {
+	const offX = options.offsetX ?? 0;
+	const offY = options.offsetY ?? 0;
+	const offZ = options.offsetZ ?? 0;
+	if (!target || typeof target !== "object") return node;
+	if ("screenX" in target && target.screenX && typeof target.screenX === "object") {
+		const signals = target;
+		node.x = offX !== 0 ? signals.screenX.add(offX) : signals.screenX;
+		node.y = offY !== 0 ? signals.screenY.add(offY) : signals.screenY;
+		node.z = offZ !== 0 ? signals.z.add(offZ) : signals.z;
+	} else if ("x" in target && typeof target.x === "object" && target.x !== null) {
+		const signals = target;
+		node.x = offX !== 0 ? signals.x.add(offX) : signals.x;
+		node.y = offY !== 0 ? signals.y.add(offY) : signals.y;
+		node.z = offZ !== 0 ? signals.z.add(offZ) : signals.z;
+	} else {
+		const staticCoord = target;
+		node.x = (staticCoord.screenX ?? staticCoord.x) + offX;
+		node.y = (staticCoord.screenY ?? staticCoord.y) + offY;
+		node.z = (staticCoord.z ?? 0) + offZ;
+	}
+	return node;
+}
+function pinNodeToObject(node, target, options = {}) {
+	if (!target || typeof target !== "object") return node;
+	if ("anchors" in target && target.anchors) {
+		const track = target;
+		const anchorName = options.anchor ?? (options.matchWidth || options.matchHeight ? "topLeft" : "center");
+		const rawAnchor = track.anchors[anchorName] ?? track.center;
+		let resolvedAnchor = rawAnchor;
+		if (options.smoothFrames && options.smoothFrames > 1) resolvedAnchor = {
+			x: rawAnchor.x.smooth(options.smoothFrames),
+			y: rawAnchor.y.smooth(options.smoothFrames),
+			z: rawAnchor.z,
+			screenX: rawAnchor.screenX.smooth(options.smoothFrames),
+			screenY: rawAnchor.screenY.smooth(options.smoothFrames)
+		};
+		if (options.matchWidth) node.width = options.smoothFrames && options.smoothFrames > 1 ? track.bounds.screenWidth.smooth(options.smoothFrames) : track.bounds.screenWidth;
+		if (options.matchHeight) node.height = options.smoothFrames && options.smoothFrames > 1 ? track.bounds.screenHeight.smooth(options.smoothFrames) : track.bounds.screenHeight;
+		if (options.hideWhenLost) node.opacity = track.active;
+		return pinNodeToLandmark(node, resolvedAnchor, options);
+	}
+	return pinNodeToLandmark(node, target, options);
+}
+/** Tasks a config turns on; detection is the default when nothing is enabled explicitly. */
+function enabledTasks(config) {
+	const tasks = [];
+	if (config.enableDetection === true) tasks.push("detect");
+	if (config.enableSegmentation === true) tasks.push("segment");
+	if (config.enablePose === true) tasks.push("pose");
+	if (config.enableMatte === true) tasks.push("matte");
+	return tasks.length > 0 ? tasks : ["detect"];
+}
+/**
+* Vision node.
+*
+* LAZY BY CONSTRUCTION: creating a VisionNode performs ZERO I/O — no model downloads, no
+* sessions, no file probes. The first inference call (or an explicit `await vision.ready()`)
+* downloads the required models.
+*/
+var VisionNode = class VisionNode$1 {
+	id;
+	kind = "vision";
+	source;
+	config;
+	vision;
+	_runner;
+	/** Runner construction options (modelsDir, provider, store, …) — injectable for tests/agents. */
+	_runnerOptions;
+	constructor(source, config = {}, bundleOptions = {}, runnerOptions = {}) {
+		this.id = `vision-${Math.random().toString(36).slice(2, 9)}`;
+		this.source = source;
+		this.config = config;
+		this._runnerOptions = runnerOptions;
+		this.vision = new VisionBundle({
+			...bundleOptions,
+			config
+		});
+	}
+	/** Lazily-created runner; downloads happen on its first inference. */
+	runner() {
+		if (!this._runner) {
+			const { variant, confidence, classes, modelsDir, baseUrl, maskThreshold, featherRadius } = this.config;
+			this._runner = VisionRunner.create({
+				...this._runnerOptions,
+				...variant !== void 0 ? { variant } : {},
+				...confidence !== void 0 ? { confidence } : {},
+				...classes !== void 0 ? { classes } : {},
+				...modelsDir !== void 0 ? { modelsDir } : {},
+				...baseUrl !== void 0 ? { baseUrl } : {},
+				...maskThreshold !== void 0 ? { maskThreshold } : {},
+				...featherRadius !== void 0 ? { featherRadius } : {}
+			});
+		}
+		return this._runner;
+	}
+	/** Explicit warm-up — downloads the models for the enabled tasks, ahead of first inference. */
+	async ready() {
+		const runner = this.runner();
+		await runner.preload(enabledTasks(this.config));
+		return runner;
+	}
+	close() {
+		this._runner?.close();
+		this._runner = void 0;
+	}
+	static attach(source, config = {}, bundleOptions = {}) {
+		const node = new VisionNode$1(source, config, bundleOptions);
+		const vision = node.vision;
+		Object.defineProperties(vision, {
+			node: {
+				value: node.toNode(),
+				enumerable: true
+			},
+			ready: { value: () => node.ready() },
+			runner: { value: () => node.runner() },
+			close: { value: () => node.close() }
+		});
+		return vision;
+	}
+	toNode() {
+		return {
+			id: this.id,
+			kind: "vision",
+			source: this.source,
+			config: this.config
+		};
+	}
+};
+
+//#endregion
+//#region ../../nodes/node-vision/dist/renderers-B24hckhO.mjs
+let scratchValues = new Uint8Array(0);
+let scratchLengths = new Uint32Array(0);
+function encodeMask(mask, width, height) {
+	if (scratchValues.length < mask.length) {
+		scratchValues = new Uint8Array(mask.length);
+		scratchLengths = new Uint32Array(mask.length);
+	}
+	const values = scratchValues;
+	const lengths = scratchLengths;
+	let runs = 0;
+	let start = 0;
+	for (let i = 1; i <= mask.length; i++) if (i === mask.length || mask[i] !== mask[start]) {
+		values[runs] = mask[start];
+		lengths[runs] = i - start;
+		runs++;
+		start = i;
+	}
+	return {
+		width,
+		height,
+		values: values.slice(0, runs),
+		lengths: lengths.slice(0, runs)
+	};
+}
+function decodeMask(rle) {
+	const out = new Uint8Array(rle.width * rle.height);
+	let at = 0;
+	for (let r = 0; r < rle.values.length; r++) {
+		const end = at + rle.lengths[r];
+		if (rle.values[r] !== 0) out.fill(rle.values[r], at, end);
+		at = end;
+	}
+	return out;
+}
+function rleBytes(rle) {
+	return rle.values.byteLength + rle.lengths.byteLength;
+}
+function toCachedMask(mask) {
+	const { mask: data, ...rest } = mask;
+	return {
+		...rest,
+		rle: encodeMask(data, mask.width, mask.height)
+	};
+}
+function fromCachedMask(mask) {
+	const { rle, ...rest } = mask;
+	return {
+		...rest,
+		mask: decodeMask(rle)
+	};
+}
+function resultBytes(result) {
+	let bytes = 512 + result.detections.length * 128 + result.objects.length * 256;
+	for (const m of result.masks ?? []) bytes += rleBytes(m.rle);
+	if (result.subject) bytes += rleBytes(result.subject.mask.rle);
+	return bytes;
+}
+/** Results by source (node + inference settings) and frame, least recently used out first. */
+var VisionFrameCache = class {
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	constructor(maxBytes = 256 * 1024 * 1024) {
+		this.maxBytes = maxBytes;
+	}
+	get(source, frame) {
+		const key = `${source}#${frame}`;
+		const hit = this.entries.get(key);
+		if (hit) {
+			this.entries.delete(key);
+			this.entries.set(key, hit);
+		}
+		return hit;
+	}
+	set(source, frame, result) {
+		const key = `${source}#${frame}`;
+		const old = this.entries.get(key);
+		if (old) {
+			this.bytes -= resultBytes(old);
+			this.entries.delete(key);
+		}
+		this.entries.set(key, result);
+		this.bytes += resultBytes(result);
+		for (const [k, v] of this.entries) {
+			if (this.bytes <= this.maxBytes) break;
+			this.entries.delete(k);
+			this.bytes -= resultBytes(v);
+		}
+	}
+	clear() {
+		this.entries.clear();
+		this.bytes = 0;
+	}
+	get size() {
+		return this.entries.size;
+	}
+};
+/**
+* GPU composite for the mask-family modes: the picture times the subject mask,
+* in one full-screen pass. Replaces building the RGBA result on the CPU and
+* uploading it; only the 8-bit mask goes to the GPU.
+*
+*  - matte: picture × mask (premultiplied, so the background is transparent)
+*  - mask:  white silhouette (rgb = mask, a = 1)
+*  - crop:  matte, with the subject's bounding box stretched to the frame
+*/
+const WGSL = `
+struct Params {
+	mode: u32,          // 0 matte, 1 mask, 2 crop
+	_pad: u32,
+	cropMin: vec2<f32>, // uv of the subject bounds (crop)
+	cropMax: vec2<f32>,
+	_pad2: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var picture: texture_2d<f32>;
+@group(0) @binding(2) var mask: texture_2d<f32>;
+@group(0) @binding(3) var samp: sampler;
+
+struct VSOut {
+	@builtin(position) pos: vec4<f32>,
+	@location(0) uv: vec2<f32>,
+};
+
+@vertex fn vs(@builtin(vertex_index) i: u32) -> VSOut {
+	var p = array<vec2<f32>, 3>(vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
+	var out: VSOut;
+	out.pos = vec4(p[i], 0.0, 1.0);
+	out.uv = vec2(p[i].x * 0.5 + 0.5, 0.5 - p[i].y * 0.5);
+	return out;
+}
+
+@fragment fn fs(in: VSOut) -> @location(0) vec4<f32> {
+	var uv = in.uv;
+	if (params.mode == 2u) {
+		uv = mix(params.cropMin, params.cropMax, uv);
+	}
+	let m = textureSampleLevel(mask, samp, uv, 0.0).r;
+	if (params.mode == 1u) {
+		return vec4(m, m, m, 1.0);
+	}
+	return textureSampleLevel(picture, samp, uv, 0.0) * m;
+}
+`;
+var MatteCompositor = class {
+	pipeline;
+	sampler;
+	uniforms = [];
+	uniformIndex = 0;
+	/** One 8-bit mask texture per node, rewritten each frame. */
+	masks = /* @__PURE__ */ new Map();
+	constructor(device, format) {
+		this.device = device;
+		const module = device.createShaderModule({
+			label: "vision_matte_composite",
+			code: WGSL
+		});
+		this.pipeline = device.createRenderPipeline({
+			label: "vision_matte_composite",
+			layout: "auto",
+			vertex: {
+				module,
+				entryPoint: "vs"
+			},
+			fragment: {
+				module,
+				entryPoint: "fs",
+				targets: [{ format }]
+			},
+			primitive: { topology: "triangle-list" }
+		});
+		this.sampler = device.createSampler({
+			magFilter: "linear",
+			minFilter: "linear"
+		});
+	}
+	/** Uploads a frame-sized 0..255 mask for `key` and returns its texture. */
+	uploadMask(key, mask, width, height) {
+		let tex = this.masks.get(key);
+		if (!tex || tex.width !== width || tex.height !== height) {
+			tex?.destroy();
+			tex = this.device.createTexture({
+				label: `vision_mask_${key}`,
+				size: [width, height],
+				format: "r8unorm",
+				usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+			});
+			this.masks.set(key, tex);
+		}
+		const aligned = Math.ceil(width / 256) * 256;
+		let bytes = mask;
+		if (aligned !== width) {
+			bytes = new Uint8Array(aligned * height);
+			for (let y = 0; y < height; y++) bytes.set(mask.subarray(y * width, (y + 1) * width), y * aligned);
+		}
+		this.device.queue.writeTexture({ texture: tex }, bytes.buffer, {
+			offset: bytes.byteOffset,
+			bytesPerRow: aligned,
+			rowsPerImage: height
+		}, {
+			width,
+			height
+		});
+		return tex;
+	}
+	/** Clears `target` and draws `picture` through `mask` into it. */
+	draw(encoder, target, picture, mask, mode, bounds) {
+		const w = mask.width;
+		const h = mask.height;
+		const data = new Float32Array(8);
+		const view = new Uint32Array(data.buffer);
+		view[0] = mode === "matte" ? 0 : mode === "mask" ? 1 : 2;
+		if (mode === "crop" && bounds) {
+			data[2] = bounds.x0 / w;
+			data[3] = bounds.y0 / h;
+			data[4] = (bounds.x1 + 1) / w;
+			data[5] = (bounds.y1 + 1) / h;
+		} else {
+			data[2] = 0;
+			data[3] = 0;
+			data[4] = 1;
+			data[5] = 1;
+			if (mode === "crop") view[0] = 0;
+		}
+		if (this.uniformIndex >= this.uniforms.length) this.uniforms.push(this.device.createBuffer({
+			size: data.byteLength,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+		}));
+		const uniform = this.uniforms[this.uniformIndex];
+		this.uniformIndex = (this.uniformIndex + 1) % 16;
+		this.device.queue.writeBuffer(uniform, 0, data);
+		const bindGroup = this.device.createBindGroup({
+			layout: this.pipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: uniform }
+				},
+				{
+					binding: 1,
+					resource: picture.createView()
+				},
+				{
+					binding: 2,
+					resource: mask.createView()
+				},
+				{
+					binding: 3,
+					resource: this.sampler
+				}
+			]
+		});
+		const pass = encoder.beginRenderPass({
+			label: "vision_matte_composite",
+			colorAttachments: [{
+				view: target,
+				loadOp: "clear",
+				storeOp: "store",
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				}
+			}]
+		});
+		pass.setPipeline(this.pipeline);
+		pass.setBindGroup(0, bindGroup);
+		pass.draw(3);
+		pass.end();
+	}
+};
+let sharedRunner = null;
+let sharedSkeletonRenderer = null;
+let sharedCompositor = null;
+let sharedCompositorFormat = null;
+/** Analysed frames, shared by every vision node in the process. */
+const frameCache = new VisionFrameCache();
+/** The frame each node's child texture holds (drawn on its last call). */
+const heldFrameByNode = /* @__PURE__ */ new Map();
+/** Per node: a copy of the held frame, and the composited matte. */
+const heldTextures = /* @__PURE__ */ new Map();
+const matteTextures = /* @__PURE__ */ new Map();
+/** One tracker per vision node — track ids must not mix across nodes/sources. */
+const objectTrackers = /* @__PURE__ */ new Map();
+/**
+* Persistent per-node child textures. The shared frame encoder is submitted at
+* the END of the frame, so a node renderer cannot read back the child it just
+* drew. We keep the texture around and read back the PREVIOUS frame's pixels at
+* the start of the next call — a stable one-frame delay instead of the
+* unpredictable multi-frame lag you get from pooled textures.
+*
+* Keyed on the stable Vision `Effect` instance (render ids change every frame),
+* with a size-keyed fallback for raw operation nodes.
+*/
+const childTexturesByEffect = /* @__PURE__ */ new WeakMap();
+const childTexturesByKey = /* @__PURE__ */ new Map();
+/**
+* Last successful subject mask, reused for a few frames when the model misses —
+* a transient miss then holds the silhouette instead of flashing the raw plate.
+* Keyed per node/effect so multiple vision nodes do not collide.
+*/
+const lastSubjectByNode = /* @__PURE__ */ new Map();
+const SUBJECT_HOLD_FRAMES = 3;
+/** A per-node texture shaped like `like`, recreated when the size changes. */
+function nodeTexture(textures, device, key, like, usage, label) {
+	let tex = textures.get(key);
+	if (!tex || tex.width !== like.width || tex.height !== like.height || tex.format !== like.format) {
+		tex?.destroy();
+		tex = device.createTexture({
+			size: [like.width, like.height],
+			format: like.format,
+			usage,
+			label
+		});
+		textures.set(key, tex);
+	}
+	return tex;
+}
+const heldTexture = (device, key, like) => nodeTexture(heldTextures, device, key, like, GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, "vision_held_frame");
+const matteTexture = (device, key, like) => nodeTexture(matteTextures, device, key, like, GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC, "vision_matte");
+/** Everything that decides a frame's results besides the frame itself. */
+function cacheSource(nodeKey, child, op, width, height) {
+	const c = child;
+	return JSON.stringify([
+		nodeKey,
+		c?.operation?.id ?? c?.id ?? null,
+		width,
+		height,
+		op.mode ?? "passthrough",
+		op.variant,
+		op.confidence,
+		op.classes,
+		op.maskThreshold,
+		op.featherRadius,
+		op.matteSource,
+		op.keyBackground === true,
+		op.maxMissedFrames
+	]);
+}
+/** The background-key threshold at `frame` (it may be animated). */
+function backgroundKeyThreshold(op, frame, fps) {
+	const raw = op.backgroundKeyThreshold;
+	if (typeof raw === "number") return raw;
+	if (typeof raw?.get === "function") return Number(raw.get({
+		frame,
+		fps
+	}));
+	if (typeof raw?._value === "number") return Number(raw._value);
+	return 70;
+}
+/**
+* The model's subject, or the last one through brief misses: a transient miss
+* then holds the silhouette instead of flashing the raw plate.
+*/
+function selectSubject(selected, nodeKey, frame) {
+	if (selected) {
+		lastSubjectByNode.set(nodeKey, {
+			mask: selected,
+			frame
+		});
+		return selected;
+	}
+	const last = lastSubjectByNode.get(nodeKey);
+	if (last && frame - last.frame <= SUBJECT_HOLD_FRAMES) return last.mask;
+}
+/**
+* Lazy shared runner — `create()` is a pure constructor (zero I/O); the first frame that
+* requests a task triggers that task's model download at inference time (never at init).
+* Recreated only when an option that changes inference changes.
+*/
+function getSharedRunner(op) {
+	const options = {
+		variant: op.variant,
+		confidence: op.confidence,
+		classes: op.classes,
+		maskThreshold: op.maskThreshold,
+		featherRadius: op.featherRadius,
+		modelsDir: op.modelsDir,
+		baseUrl: op.baseUrl
+	};
+	const key = JSON.stringify(options);
+	if (sharedRunner?.key !== key) {
+		sharedRunner?.runner.close();
+		sharedRunner = {
+			key,
+			runner: VisionRunner.create(options)
+		};
+	}
+	return sharedRunner.runner;
+}
+function getObjectTracker(nodeKey, op) {
+	let tracker = objectTrackers.get(nodeKey);
+	if (!tracker) {
+		tracker = new TemporalObjectTracker({ maxMissedFrames: op.maxMissedFrames ?? 15 });
+		objectTrackers.set(nodeKey, tracker);
+	}
+	return tracker;
+}
+/**
+* Normalizes the runner's pose keypoints (plate pixel space) to [0, 1] landmarks, which is
+* the contract the signal bundle and the skeleton pipeline expect.
+*/
+function normalizePoseKeypoints(result, width, height) {
+	if (width <= 0 || height <= 0) return result;
+	return { people: result.people.map((person) => ({
+		...person,
+		keypoints: person.keypoints.map((k) => ({
+			x: k.x / width,
+			y: k.y / height,
+			visibility: k.visibility
+		}))
+	})) };
+}
+/** Assigns each decoded instance mask to the temporal track whose box center is nearest the mask's centroid. */
+function assignMasksToTracks(masks, tracked) {
+	return masks.map((mask) => {
+		const { cx, cy } = maskCentroid(mask);
+		let best = null;
+		for (const obj of tracked) {
+			const dx = obj.centerX - cx;
+			const dy = obj.centerY - cy;
+			const distance = dx * dx + dy * dy;
+			if (!best || distance < best.distance) best = {
+				trackId: obj.trackId,
+				distance
+			};
+		}
+		return best ? {
+			...mask,
+			trackId: best.trackId
+		} : mask;
+	});
+}
+/**
+* Grows a subject mask into connected foreground pixels — seeding a flood fill
+* from the subject through pixels that differ from the sampled backdrop recovers
+* thin or fast-moving edges (hair, fabric) without adding a near-uniform studio
+* wall or its soft grey shadow.
+*/
+function fillInternalHoles(mask, width, height) {
+	const n = width * height;
+	const exterior = new Uint8Array(n);
+	const queue = new Int32Array(n);
+	let tail = 0;
+	const seed = (i) => {
+		if (exterior[i] || mask[i] > 0) return;
+		exterior[i] = 1;
+		queue[tail++] = i;
+	};
+	for (let x = 0; x < width; x++) {
+		seed(x);
+		seed((height - 1) * width + x);
+	}
+	for (let y = 0; y < height; y++) {
+		seed(y * width);
+		seed(y * width + width - 1);
+	}
+	let head = 0;
+	while (head < tail) {
+		const i = queue[head++];
+		const x = i % width;
+		let j = i + 1;
+		if (x + 1 < width && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+		j = i - 1;
+		if (x > 0 && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+		j = i + width;
+		if (j < n && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+		j = i - width;
+		if (j >= 0 && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+	}
+	for (let i = 0; i < n; i++) if (mask[i] === 0 && exterior[i] === 0) mask[i] = 255;
+}
+function smoothMaskBoundary(mask, width, height, radius = 2) {
+	if (radius <= 0) return mask;
+	const temp = new Uint8Array(width * height);
+	const out = new Uint8Array(width * height);
+	const div = 2 * radius + 1;
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		let sum = 0;
+		for (let k = -radius; k <= radius; k++) {
+			const x = Math.max(0, Math.min(width - 1, k));
+			sum += mask[row + x];
+		}
+		for (let x = 0; x < width; x++) {
+			temp[row + x] = Math.round(sum / div);
+			const xOut = Math.max(0, x - radius);
+			const xIn = Math.min(width - 1, x + radius + 1);
+			sum += mask[row + xIn] - mask[row + xOut];
+		}
+	}
+	const sums = new Float64Array(width);
+	for (let k = -radius; k <= radius; k++) {
+		const row = Math.max(0, Math.min(height - 1, k)) * width;
+		for (let x = 0; x < width; x++) sums[x] += temp[row + x];
+	}
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		const rowOut = Math.max(0, y - radius) * width;
+		const rowIn = Math.min(height - 1, y + radius + 1) * width;
+		for (let x = 0; x < width; x++) {
+			out[row + x] = Math.round(sums[x] / div);
+			sums[x] += temp[rowIn + x] - temp[rowOut + x];
+		}
+	}
+	return out;
+}
+function growMaskIntoForeground(mask, width, height, pixels, threshold, featherRadius) {
+	let br = 0;
+	let bg = 0;
+	let bb = 0;
+	let count = 0;
+	const sample = (x, y) => {
+		const i = y * width + x;
+		if (mask[i]) return;
+		const p = i * 4;
+		br += pixels[p];
+		bg += pixels[p + 1];
+		bb += pixels[p + 2];
+		count++;
+	};
+	for (let x = 0; x < width; x += 4) {
+		sample(x, 0);
+		sample(x, height - 1);
+	}
+	for (let y = 0; y < height; y += 4) {
+		sample(0, y);
+		sample(width - 1, y);
+	}
+	if (count === 0) return mask;
+	br /= count;
+	bg /= count;
+	bb /= count;
+	const n = width * height;
+	const fg = new Uint8Array(n);
+	for (let i = 0, p = 0; i < n; i++, p += 4) fg[i] = Math.max(Math.abs(pixels[p] - br), Math.abs(pixels[p + 1] - bg), Math.abs(pixels[p + 2] - bb)) > threshold ? 1 : 0;
+	const queue = new Int32Array(n);
+	let tail = 0;
+	for (let i = 0; i < n; i++) if (mask[i] > 0) {
+		if (fg[i]) mask[i] = 255;
+		queue[tail++] = i;
+	}
+	let head = 0;
+	while (head < tail) {
+		const i = queue[head++];
+		const x = i % width;
+		let j = i + 1;
+		if (x + 1 < width && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+		j = i - 1;
+		if (x > 0 && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+		j = i + width;
+		if (j < n && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+		j = i - width;
+		if (j >= 0 && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+	}
+	fillInternalHoles(mask, width, height);
+	return smoothMaskBoundary(mask, width, height, featherRadius !== void 0 && featherRadius > 0 ? Math.max(1, Math.min(8, Math.round(featherRadius * 50))) : 2);
+}
+function maskCentroid(mask) {
+	const { mask: data, width, height } = mask;
+	let sumX = 0;
+	let sumY = 0;
+	let count = 0;
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		for (let x = 0; x < width; x++) if (data[row + x] > 0) {
+			sumX += x;
+			sumY += y;
+			count++;
+		}
+	}
+	if (count === 0) return {
+		cx: 0,
+		cy: 0
+	};
+	return {
+		cx: sumX / count,
+		cy: sumY / count
+	};
+}
+const VisionWebGPURenderer = async (args) => {
+	const { ctx, encoder, pass, targetView, targetWidth, targetHeight, props, drawChild } = args;
+	const { virtualMedia } = props;
+	const rawOp = virtualMedia?.operation;
+	if (rawOp?.op !== "Vision") return;
+	const op = rawOp;
+	pass.end();
+	const childMedia = virtualMedia?.children?.[0];
+	if (!childMedia) return;
+	const effectKey = op.effect;
+	const hasEffectKey = effectKey !== void 0 && effectKey !== null;
+	const nodeKeyStr = virtualMedia?.id ?? rawOp?.id ?? `${targetWidth}x${targetHeight}_${op.mode}_${op.variant}_${op.keyBackground}_${op.backgroundKeyThreshold}`;
+	const fallbackKey = `vision-${nodeKeyStr}`;
+	let childTex = hasEffectKey ? childTexturesByEffect.get(effectKey) : childTexturesByKey.get(fallbackKey);
+	if (childTex && (childTex.width !== targetWidth || childTex.height !== targetHeight)) {
+		childTex.destroy();
+		childTex = void 0;
+		if (hasEffectKey) childTexturesByEffect.delete(effectKey);
+		else childTexturesByKey.delete(fallbackKey);
+	}
+	const hasPreviousFrame = childTex !== void 0;
+	if (!childTex) {
+		childTex = ctx.device.createTexture({
+			size: [targetWidth, targetHeight],
+			format: ctx.renderer.format,
+			usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
+			label: "vision_child_persistent"
+		});
+		if (hasEffectKey) childTexturesByEffect.set(effectKey, childTex);
+		else childTexturesByKey.set(fallbackKey, childTex);
+		if (childTexturesByKey.size > 4) {
+			const oldest = childTexturesByKey.keys().next().value;
+			if (oldest && oldest !== fallbackKey) {
+				childTexturesByKey.get(oldest)?.destroy();
+				childTexturesByKey.delete(oldest);
+			}
+		}
+	}
+	const frameIdx = props.frame ?? 0;
+	const fps = props.fps ?? 24;
+	const mode = op.mode ?? "passthrough";
+	const isMatteMode = mode === "mask" || mode === "matte" || mode === "crop";
+	const visionBundle = op.visionBundle ?? virtualMedia.visionBundle;
+	const wantsDetection = op.enableDetection !== false || mode === "boxes" || mode === "tracking";
+	const wantsSegmentation = op.enableSegmentation === true || isMatteMode && op.matteSource !== "selfie";
+	const wantsSelfie = op.enableMatte === true || isMatteMode && op.matteSource === "selfie";
+	const wantsPose = op.enablePose === true || mode === "skeleton";
+	const cacheable = !wantsSelfie && !wantsPose && (wantsDetection || wantsSegmentation);
+	const source = cacheable ? cacheSource(nodeKeyStr, childMedia, op, targetWidth, targetHeight) : "";
+	const keyThresholdAt = (frame) => op.keyBackground === true ? backgroundKeyThreshold(op, frame, fps) : void 0;
+	const lookup = (frame) => {
+		if (!cacheable || frame === void 0) return void 0;
+		const hit = frameCache.get(source, frame);
+		if (!hit || hit.keyThreshold !== keyThresholdAt(frame)) return void 0;
+		if (wantsSegmentation && visionBundle && !hit.masks) return void 0;
+		return hit;
+	};
+	const heldFrame = hasPreviousFrame ? heldFrameByNode.get(nodeKeyStr) : void 0;
+	let cached = lookup(frameIdx);
+	const exact = cached !== void 0;
+	if (!cached) cached = lookup(heldFrame);
+	let heldTex;
+	if (isMatteMode && hasPreviousFrame && !exact) {
+		heldTex = heldTexture(ctx.device, nodeKeyStr, childTex);
+		encoder.copyTextureToTexture({ texture: childTex }, { texture: heldTex }, [
+			targetWidth,
+			targetHeight,
+			1
+		]);
+	}
+	let framePixels = null;
+	if (hasPreviousFrame && !cached) {
+		const unalignedBytesPerRow = targetWidth * 4;
+		const bytesPerRow = Math.ceil(unalignedBytesPerRow / 256) * 256;
+		const bufferSize = bytesPerRow * targetHeight;
+		const stagingBuffer = ctx.device.createBuffer({
+			size: bufferSize,
+			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+			label: "vision_frame_staging"
+		});
+		const readbackEncoder = ctx.device.createCommandEncoder({ label: "vision_readback_encoder" });
+		readbackEncoder.copyTextureToBuffer({ texture: childTex }, {
+			buffer: stagingBuffer,
+			bytesPerRow,
+			rowsPerImage: targetHeight
+		}, [
+			targetWidth,
+			targetHeight,
+			1
+		]);
+		ctx.device.queue.submit([readbackEncoder.finish()]);
+		await stagingBuffer.mapAsync(GPUMapMode.READ);
+		const mappedBytes = new Uint8Array(stagingBuffer.getMappedRange());
+		framePixels = new Uint8ClampedArray(targetWidth * targetHeight * 4);
+		if (bytesPerRow === unalignedBytesPerRow) framePixels.set(mappedBytes.subarray(0, framePixels.length));
+		else for (let y = 0; y < targetHeight; y++) framePixels.set(mappedBytes.subarray(y * bytesPerRow, y * bytesPerRow + unalignedBytesPerRow), y * unalignedBytesPerRow);
+		stagingBuffer.unmap();
+		stagingBuffer.destroy();
+	}
+	const childView = childTex.createView();
+	ctx.renderer.beginFrame(encoder, childView, {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 0
+	}, targetWidth, targetHeight, "clear").end();
+	await drawChild(childMedia, { ...props }, childView, childTex, targetWidth, targetHeight);
+	heldFrameByNode.set(nodeKeyStr, frameIdx);
+	let frameObjects = [];
+	let frameMasks = [];
+	let personMatte;
+	let currentPoseRes;
+	let subject;
+	if (cached) {
+		frameObjects = cached.objects;
+		if (wantsDetection) visionBundle?.setObjectResult(frameIdx, {
+			objects: cached.objects,
+			rawDetections: cached.detections
+		});
+		if (wantsSegmentation && visionBundle && cached.masks) {
+			frameMasks = cached.masks.map(fromCachedMask);
+			visionBundle.setMaskResult(frameIdx, frameMasks);
+		}
+		if (cached.subject) {
+			subject = fromCachedMask(cached.subject.mask);
+			lastSubjectByNode.set(nodeKeyStr, {
+				mask: subject,
+				frame: frameIdx
+			});
+		}
+	} else if (framePixels) {
+		const runner = getSharedRunner(op);
+		const image = {
+			data: framePixels,
+			width: targetWidth,
+			height: targetHeight
+		};
+		let detections = [];
+		if (wantsDetection) {
+			detections = await runner.detect(image);
+			const tracker = getObjectTracker(nodeKeyStr, op);
+			if (frameIdx === 0) tracker.reset();
+			frameObjects = tracker.update(detections, frameIdx, fps);
+			visionBundle?.setObjectResult(frameIdx, {
+				objects: frameObjects,
+				rawDetections: detections
+			});
+		}
+		if (wantsSegmentation) {
+			frameMasks = assignMasksToTracks((await runner.segment(image)).masks, frameObjects);
+			visionBundle?.setMaskResult(frameIdx, frameMasks);
+		}
+		if (wantsSelfie) {
+			personMatte = await runner.matte(image);
+			visionBundle?.setMatteResult(frameIdx, personMatte);
+		}
+		if (wantsPose) {
+			currentPoseRes = { people: matchPoseToTracks(normalizePoseKeypoints(await runner.pose(image), image.width, image.height).people, frameObjects) };
+			visionBundle?.setPoseResult(frameIdx, currentPoseRes);
+		}
+		if (isMatteMode) {
+			subject = selectSubject(op.matteSource === "selfie" ? personMatteAsMask(personMatte) : mergeSubjectMask(frameMasks.length > 0 ? frameMasks : visionBundle?.getMaskResult(frameIdx) ?? []), nodeKeyStr, frameIdx);
+			const threshold = keyThresholdAt(heldFrame ?? frameIdx);
+			if (subject && threshold !== void 0) subject = {
+				...subject,
+				mask: growMaskIntoForeground(subject.mask, subject.width, subject.height, framePixels, threshold, op.featherRadius)
+			};
+		}
+		if (cacheable && heldFrame !== void 0) frameCache.set(source, heldFrame, {
+			detections,
+			objects: frameObjects,
+			masks: visionBundle ? frameMasks.map(toCachedMask) : null,
+			subject: subject ? { mask: toCachedMask(subject) } : null,
+			keyThreshold: keyThresholdAt(heldFrame)
+		});
+	}
+	if (isMatteMode) {
+		const picture = exact ? childTex : heldTex;
+		if (!subject || !picture) {
+			ctx.renderer.beginFrame(encoder, targetView, {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 0
+			}, targetWidth, targetHeight, "clear").end();
+			return;
+		}
+		if (!sharedCompositor || sharedCompositorFormat !== ctx.renderer.format) {
+			sharedCompositor = new MatteCompositor(ctx.device, ctx.renderer.format);
+			sharedCompositorFormat = ctx.renderer.format;
+		}
+		const maskTex = sharedCompositor.uploadMask(nodeKeyStr, subject.mask, subject.width, subject.height);
+		const matteTex = matteTexture(ctx.device, nodeKeyStr, childTex);
+		sharedCompositor.draw(encoder, matteTex.createView(), picture, maskTex, mode, mode === "crop" ? maskBounds(subject) ?? void 0 : void 0);
+		visionBundle?.setStencilTexture(matteTex);
+		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "clear");
+		ctx.renderer.drawTexture(outPass$1, matteTex, {
+			x: 0,
+			y: 0,
+			width: targetWidth,
+			height: targetHeight
+		});
+		outPass$1.end();
+		return;
+	}
+	if (mode === "skeleton") {
+		if (!sharedSkeletonRenderer) sharedSkeletonRenderer = new PoseSkeletonRenderer(ctx.device);
+		const person = (visionBundle?.getPoseResult(frameIdx) ?? currentPoseRes)?.people[0];
+		if (person && person.keypoints.length > 0) {
+			const skelTex = sharedSkeletonRenderer.renderToTexture(person.keypoints, {
+				width: targetWidth,
+				height: targetHeight
+			});
+			const skelPass = ctx.renderer.beginFrame(encoder, targetView, {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 0
+			}, targetWidth, targetHeight, "clear");
+			ctx.renderer.drawTexture(skelPass, skelTex, {
+				x: 0,
+				y: 0,
+				width: targetWidth,
+				height: targetHeight
+			});
+			skelPass.end();
+			return;
+		}
+	}
+	if (mode === "boxes" || mode === "tracking") {
+		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "clear");
+		ctx.renderer.drawTexture(outPass$1, childTex, {
+			x: 0,
+			y: 0,
+			width: targetWidth,
+			height: targetHeight
+		});
+		const objects = frameObjects.length > 0 ? frameObjects : visionBundle?.getObjectResult(frameIdx).objects ?? [];
+		if (objects.length > 0) {
+			const boxColor = "#38bdf8";
+			const stroke = 2;
+			for (const obj of objects) {
+				if (!obj.active) continue;
+				const b = obj.boundingBox;
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: b.width,
+					height: stroke
+				}, boxColor);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY + b.height - stroke,
+					width: b.width,
+					height: stroke
+				}, boxColor);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: stroke,
+					height: b.height
+				}, boxColor);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX + b.width - stroke,
+					y: b.originY,
+					width: stroke,
+					height: b.height
+				}, boxColor);
+				const cornerLen = Math.min(16, b.width / 4, b.height / 4);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: cornerLen,
+					height: stroke * 2
+				}, "#ffffff");
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: stroke * 2,
+					height: cornerLen
+				}, "#ffffff");
+				if (mode === "tracking") ctx.renderer.drawRect(outPass$1, {
+					x: obj.centerX - 3,
+					y: obj.centerY - 3,
+					width: 6,
+					height: 6
+				}, "#ef4444", 3);
+			}
+		}
+		outPass$1.end();
+		return;
+	}
+	const outPass = ctx.renderer.beginFrame(encoder, targetView, {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 0
+	}, targetWidth, targetHeight, "clear");
+	ctx.renderer.drawTexture(outPass, childTex, {
+		x: 0,
+		y: 0,
+		width: targetWidth,
+		height: targetHeight
+	});
+	outPass.end();
+};
+/** Adapts a Selfie Segmenter matte to the instance-mask shape the composite path takes. */
+function personMatteAsMask(matte) {
+	if (!matte || matte.coverage <= 0) return void 0;
+	const area = Math.round(matte.coverage * matte.width * matte.height);
+	return {
+		category: "person",
+		mask: matte.mask,
+		width: matte.width,
+		height: matte.height,
+		area,
+		coverage: matte.coverage,
+		detectionIndex: -1
+	};
+}
+var renderers_default = defineRenderer({ WebGPURenderer: VisionWebGPURenderer });
+
+//#endregion
+export { PoseSkeletonRenderer as a, TemporalObjectTracker as c, VisionRunner as d, analyzeSequence as f, COCO_CLASSES as h, COCO17_KEYPOINT_NAMES as i, VisionBundle as l, pinNodeToObject as m, COCO17_BONES as n, SegmentationTexturePool as o, pinNodeToLandmark as p, COCO17_KEYPOINTS as r, SpatialLandmarkTransformer as s, renderers_default as t, VisionNode as u };
+//# sourceMappingURL=renderer-XcmYTd6P.mjs.map