@framefields/vision 0.0.0-stage → 2.0.3

package/dist/src-C2sA_wDT.mjs

@@ -0,0 +1,2973 @@
+import { n as __reExport, t as __exportAll } from "./chunk-CFhWmker.mjs";
+import { a as modelKeyFor, i as VISION_VARIANTS, n as VISION_MODELS, r as VISION_TASKS, t as COCO_CLASSES } from "./registry-CSFimt7C.mjs";
+import { PoseSkeletonComputePipeline } from "@framefields/tensor-webgpu";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { frameSignal, programmaticSignal } from "@framefields/core";
+
+//#region src/tracking/temporal-object-tracker.ts
+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;
+	}
+};
+
+//#endregion
+//#region src/analysis/analyze-sequence.ts
+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
+	};
+}
+
+//#endregion
+//#region src/decode/preprocess.ts
+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
+	};
+}
+
+//#endregion
+//#region src/decode/rtmdet-ins.ts
+/** 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;
+}
+
+//#endregion
+//#region src/decode/rtmo.ts
+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;
+}
+
+//#endregion
+//#region src/decode/selfie.ts
+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
+	};
+}
+
+//#endregion
+//#region src/pose/keypoints.ts
+/** 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
+		]
+	}
+];
+
+//#endregion
+//#region src/gpu/pose-skeleton-renderer.ts
+/**
+* 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();
+	}
+};
+
+//#endregion
+//#region src/gpu/segmentation-texture-pool.ts
+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();
+	}
+};
+
+//#endregion
+//#region src/model/model-store.ts
+/**
+* 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();
+	}
+};
+
+//#endregion
+//#region src/runner/canonical-baselines.ts
+/** 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;
+}
+
+//#endregion
+//#region src/runtime/webgpu-provider.ts
+const ORT_WEB_SPECIFIER = "onnxruntime-web";
+const defaultLoader = () => import(
+	/* @vite-ignore */
+	ORT_WEB_SPECIFIER
+);
+var WebGPUProvider = class {
+	kind = "webgpu";
+	_loader;
+	_providers;
+	_wasmFallback;
+	_ortPromise;
+	constructor(options = {}) {
+		this._loader = options.loader ?? defaultLoader;
+		this._providers = options.executionProviders ?? ["webgpu", "wasm"];
+		this._wasmFallback = options.wasmFallback !== false;
+	}
+	ort() {
+		if (!this._ortPromise) this._ortPromise = this._loader().catch((err) => {
+			this._ortPromise = void 0;
+			throw new Error(`onnxruntime-web failed to load (${String(err)}). Install it in the browser bundle or pass a custom loader.`);
+		});
+		return this._ortPromise;
+	}
+	async createSession(modelBytes) {
+		const ort = await this.ort();
+		let session;
+		try {
+			session = await ort.InferenceSession.create(modelBytes, {
+				executionProviders: [...this._providers],
+				graphOptimizationLevel: "all",
+				logSeverityLevel: 3
+			});
+		} catch (err) {
+			if (!this._wasmFallback || !this._providers.includes("webgpu")) throw err;
+			session = await ort.InferenceSession.create(modelBytes, {
+				executionProviders: ["wasm"],
+				graphOptimizationLevel: "all",
+				logSeverityLevel: 3
+			});
+		}
+		return {
+			run: async (input) => {
+				const inputName = session.inputNames.includes(input.name) ? input.name : session.inputNames[0] ?? input.name;
+				const results = await session.run({ [inputName]: new ort.Tensor("float32", input.data, [...input.dims]) });
+				const outputs = {};
+				for (const [name, tensor] of Object.entries(results)) outputs[name] = {
+					data: tensor.data,
+					dims: [...tensor.dims]
+				};
+				return outputs;
+			},
+			release: () => {
+				session.release();
+			}
+		};
+	}
+};
+/**
+* Convenience factory: a `SessionProvider` type guard for the browser entry. Kept tiny so
+* `@framefields/vision/web` stays tree-shakeable.
+*/
+function createWebGPUProvider(options) {
+	return new WebGPUProvider(options);
+}
+/** True when the environment exposes a WebGPU device (synchronous capability probe). */
+function hasWebGPU() {
+	return typeof navigator !== "undefined" && "gpu" in navigator;
+}
+
+//#endregion
+//#region src/runtime/node-webgpu-provider.ts
+const ORT_WEBGPU_SPECIFIER = "onnxruntime-web/webgpu";
+const WEBGPU_SPECIFIER = "webgpu";
+let nodeWebGPUReady;
+/**
+* Ensure `globalThis.navigator.gpu` exists. In the renderer this is already the
+* Dawn device; otherwise imports the `webgpu` (Dawn) package and installs its
+* globals plus an adapter, which is what onnxruntime-web's WebGPU EP needs.
+*/
+function ensureNodeWebGPU() {
+	if (!nodeWebGPUReady) {
+		nodeWebGPUReady = (async () => {
+			const g = globalThis;
+			if (g.navigator?.gpu) return;
+			const { create, globals } = await import(
+				/* @vite-ignore */
+				WEBGPU_SPECIFIER
+);
+			Object.assign(globalThis, globals);
+			const nav = g.navigator ??= {};
+			Object.defineProperty(nav, "gpu", {
+				value: create([]),
+				configurable: true,
+				writable: true
+			});
+		})();
+		nodeWebGPUReady.catch(() => {
+			nodeWebGPUReady = void 0;
+		});
+	}
+	return nodeWebGPUReady;
+}
+var NodeWebGPUProvider = class {
+	kind = "webgpu";
+	_inner;
+	constructor(options = {}) {
+		const loader = options.loader ?? (async () => {
+			await ensureNodeWebGPU();
+			const mod = await import(
+				/* @vite-ignore */
+				ORT_WEBGPU_SPECIFIER
+);
+			if (mod.env?.wasm) mod.env.wasm.numThreads = 1;
+			return mod;
+		});
+		this._inner = new WebGPUProvider({
+			wasmFallback: false,
+			...options,
+			loader
+		});
+	}
+	createSession(modelBytes) {
+		return this._inner.createSession(modelBytes);
+	}
+};
+function createNodeWebGPUProvider(options) {
+	return new NodeWebGPUProvider(options);
+}
+
+//#endregion
+//#region src/runtime/session-provider.ts
+let defaultProvider;
+/**
+* Sets the provider runners use when none is passed, for hosts that create
+* runners indirectly (e.g. a browser player rendering vision nodes). `undefined`
+* restores the default, onnxruntime-node.
+*/
+function setDefaultSessionProvider(factory) {
+	defaultProvider = factory;
+}
+/**
+* Prefers the GPU (onnxruntime-web's WebGPU EP on the process's WebGPU device —
+* the Dawn device the renderer already creates, or one this ensures) and falls
+* back to the CPU provider (onnxruntime-node) when a WebGPU session cannot be
+* created: no device, no Dawn, or the EP unavailable. The choice is made on the
+* first session and reused for the runner's lifetime.
+*/
+var AutoSessionProvider = class {
+	_resolved;
+	get kind() {
+		return this._resolved?.kind ?? "webgpu";
+	}
+	async createSession(modelBytes) {
+		if (!this._resolved) {
+			const webgpu = new NodeWebGPUProvider({ wasmFallback: false });
+			try {
+				const session = await webgpu.createSession(modelBytes);
+				this._resolved = webgpu;
+				return session;
+			} catch {
+				this._resolved = new NodeSessionProvider();
+			}
+		}
+		return this._resolved.createSession(modelBytes);
+	}
+};
+/**
+* The provider for a runner created without one: GPU if possible, otherwise CPU.
+*/
+function createDefaultSessionProvider() {
+	return defaultProvider?.() ?? new AutoSessionProvider();
+}
+/** 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();
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/runner/vision-runner.ts
+/**
+* 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 {
+	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(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;
+}
+
+//#endregion
+//#region src/segmentation/subject.ts
+/**
+* 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));
+}
+
+//#endregion
+//#region src/spatial/camera-space-transformer.ts
+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)
+		};
+	}
+};
+
+//#endregion
+//#region src/tracking/pose-track-matcher.ts
+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;
+	});
+}
+
+//#endregion
+//#region src/signals/vision-bundle.ts
+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)));
+	}
+};
+function createVisionBundle(options) {
+	return new VisionBundle(options);
+}
+const COCO_CLASS_INDEX_BY_NAME = new Map(COCO_CLASSES.map((name, index) => [name, index]));
+
+//#endregion
+//#region src/spatial/spatial-pin.ts
+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);
+}
+
+//#endregion
+//#region src/vision-node.ts
+/** 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 {
+	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(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 src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	AutoSessionProvider: () => AutoSessionProvider,
+	COCO17_BONES: () => COCO17_BONES,
+	COCO17_KEYPOINTS: () => COCO17_KEYPOINTS,
+	COCO17_KEYPOINT_COUNT: () => COCO17_KEYPOINT_COUNT,
+	COCO17_KEYPOINT_NAMES: () => COCO17_KEYPOINT_NAMES,
+	COCO_CLASSES: () => COCO_CLASSES,
+	NodeSessionProvider: () => NodeSessionProvider,
+	NodeWebGPUProvider: () => NodeWebGPUProvider,
+	PREPROCESS_BY_FAMILY: () => PREPROCESS_BY_FAMILY,
+	PoseSkeletonRenderer: () => PoseSkeletonRenderer,
+	SegmentationTexturePool: () => SegmentationTexturePool,
+	SpatialLandmarkTransformer: () => SpatialLandmarkTransformer,
+	TemporalObjectTracker: () => TemporalObjectTracker,
+	VISION_MODELS: () => VISION_MODELS,
+	VISION_TASKS: () => VISION_TASKS,
+	VISION_VARIANTS: () => VISION_VARIANTS,
+	VisionBundle: () => VisionBundle,
+	VisionModelStore: () => VisionModelStore,
+	VisionNode: () => VisionNode,
+	VisionRunner: () => VisionRunner,
+	analyzeSequence: () => analyzeSequence,
+	computeInputTransform: () => computeInputTransform,
+	computeIoU: () => computeIoU,
+	createDefaultSessionProvider: () => createDefaultSessionProvider,
+	createNeutralLandmarks: () => createNeutralLandmarks,
+	createNeutralObjectResult: () => createNeutralObjectResult,
+	createNeutralPoseResult: () => createNeutralPoseResult,
+	createNodeWebGPUProvider: () => createNodeWebGPUProvider,
+	createVisionBundle: () => createVisionBundle,
+	decodeRtmdetIns: () => decodeRtmdetIns,
+	decodeRtmo: () => decodeRtmo,
+	decodeSelfie: () => decodeSelfie,
+	ensureNodeWebGPU: () => ensureNodeWebGPU,
+	getDefaultModelsDir: () => getDefaultModelsDir,
+	getPersonBoundingBox: () => getPersonBoundingBox,
+	imageToTensor: () => imageToTensor,
+	maskBounds: () => maskBounds,
+	matchPoseToTracks: () => matchPoseToTracks,
+	mergeSubjectMask: () => mergeSubjectMask,
+	modelKeyFor: () => modelKeyFor,
+	pinNodeToLandmark: () => pinNodeToLandmark,
+	pinNodeToObject: () => pinNodeToObject,
+	preprocessSpec: () => preprocessSpec,
+	probabilityToAlpha: () => probabilityToAlpha,
+	selectSubjectMask: () => selectSubjectMask,
+	setDefaultSessionProvider: () => setDefaultSessionProvider,
+	toSourcePoint: () => toSourcePoint
+});
+
+//#endregion
+export { PoseSkeletonRenderer as A, computeInputTransform as B, hasWebGPU as C, VisionModelStore as D, createNeutralPoseResult as E, COCO17_KEYPOINT_COUNT as F, TemporalObjectTracker as G, preprocessSpec as H, decodeRtmo as I, computeIoU as K, decodeRtmdetIns as L, COCO17_KEYPOINTS as M, COCO17_KEYPOINT_NAMES as N, getDefaultModelsDir as O, decodeSelfie as P, probabilityToAlpha as R, createWebGPUProvider as S, createNeutralObjectResult as T, toSourcePoint as U, imageToTensor as V, analyzeSequence as W, setDefaultSessionProvider as _, VisionBundle as a, ensureNodeWebGPU as b, matchPoseToTracks as c, mergeSubjectMask as d, selectSubjectMask as f, createDefaultSessionProvider as g, NodeSessionProvider as h, pinNodeToObject as i, COCO17_BONES as j, SegmentationTexturePool as k, SpatialLandmarkTransformer as l, AutoSessionProvider as m, VisionNode as n, createVisionBundle as o, VisionRunner as p, pinNodeToLandmark as r, getPersonBoundingBox as s, src_exports as t, maskBounds as u, NodeWebGPUProvider as v, createNeutralLandmarks as w, WebGPUProvider as x, createNodeWebGPUProvider as y, PREPROCESS_BY_FAMILY as z };
+//# sourceMappingURL=src-C2sA_wDT.mjs.map