gitframes 1.2.35 → 1.3.0

package/dist/{effects-4t4qk-BR.mjs → effects-C9connag.mjs}

@@ -4,7 +4,8 @@ import { t as AudioSignal } from "./audio-CiXUMGyk.mjs";
 import { z } from "zod";
 import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { rename, unlink, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 
 //#region ../tensor-webgpu/dist/index.mjs
@@ -2225,219 +2226,106 @@ var TensorPipeline = class TensorPipeline$1 {
 };
 
 //#endregion
-//#region ../yolo/dist/src-_tHNcXK0.mjs
-/**
-* Default download origin. Override per-run with `baseUrl` option or the
-* GITFRAMES_YOLO_BASE_URL environment variable.
-*/
-const YOLO_ASSETS_RELEASE = "v8.3.0";
-const DEFAULT_YOLO_BASE_URL = `https://github.com/ultralytics/assets/releases/download/${YOLO_ASSETS_RELEASE}/`;
-const YOLO_MODELS = {
-	yolo11n: {
-		key: "yolo11n",
-		task: "detect",
-		variant: "n",
-		filename: "yolo11n.onnx",
-		bytesFp32: 10723904,
-		bytesFp16: 5361952,
-		nc: 80,
-		imgsz: 640
-	},
-	yolo11s: {
-		key: "yolo11s",
-		task: "detect",
-		variant: "s",
-		filename: "yolo11s.onnx",
-		url: "https://huggingface.co/mobilint/YOLO11s/resolve/main/yolo11s.onnx",
-		bytesFp32: 38502400,
-		bytesFp16: 19251200,
-		nc: 80,
-		imgsz: 640
-	},
-	yolo11m: {
-		key: "yolo11m",
-		task: "detect",
-		variant: "m",
-		filename: "yolo11m.onnx",
-		bytesFp32: 82329600,
-		bytesFp16: 41164800,
-		nc: 80,
-		imgsz: 640
-	},
-	yolo11l: {
-		key: "yolo11l",
-		task: "detect",
-		variant: "l",
-		filename: "yolo11l.onnx",
-		bytesFp32: 103628800,
-		bytesFp16: 51814400,
-		nc: 80,
-		imgsz: 640
-	},
-	yolo11x: {
-		key: "yolo11x",
-		task: "detect",
-		variant: "x",
-		filename: "yolo11x.onnx",
-		bytesFp32: 233062400,
-		bytesFp16: 116531200,
-		nc: 80,
-		imgsz: 640
-	},
-	"yolo11n-seg": {
-		key: "yolo11n-seg",
-		task: "segment",
-		variant: "n",
-		filename: "yolo11n-seg.onnx",
-		bytesFp32: 11886592,
-		nc: 80,
-		imgsz: 640
-	},
-	"yolo11s-seg": {
-		key: "yolo11s-seg",
-		task: "segment",
-		variant: "s",
-		filename: "yolo11s-seg.onnx",
-		url: "https://huggingface.co/mobilint/YOLO11s-seg/resolve/main/yolo11s-seg.onnx",
-		bytesFp32: 42631168,
-		nc: 80,
-		imgsz: 640
+//#region ../vision/dist/registry-CSFimt7C.mjs
+const hf = (repo, revision, path$1) => `https://huggingface.co/${repo}/resolve/${revision}/${path$1}`;
+const RTMDET_INS_REPO = "tori29umai/rtmdet-ins-onnx-person-masks";
+const RTMDET_INS_REV = "e5218e8d47d7c50077f27f9893a28e0ef2ad5656";
+const RTMDET_INS_SOURCE = "RTMDet-Ins (OpenMMLab mmdetection, Apache-2.0), mmdeploy ONNX export";
+const RTMO_SOURCE = "RTMO (OpenMMLab mmpose, Apache-2.0), ONNX export";
+const SELFIE_SOURCE = "MediaPipe Selfie Segmenter (Google, Apache-2.0), ONNX export";
+const VISION_MODELS = {
+	"rtmdet-ins-t": {
+		key: "rtmdet-ins-t",
+		family: "rtmdet-ins",
+		filename: "rtmdet-ins-t.onnx",
+		url: hf(RTMDET_INS_REPO, RTMDET_INS_REV, "models/tiny/rtmdet-ins_tiny_640x640.onnx"),
+		bytes: 24032356,
+		sha256: "99ee670820c4493aa13e20578b6a8e39781c319846dc41796a77765734beac5c",
+		input: [640, 640],
+		source: RTMDET_INS_SOURCE
 	},
-	"yolo11m-seg": {
-		key: "yolo11m-seg",
-		task: "segment",
-		variant: "m",
-		filename: "yolo11m-seg.onnx",
-		bytesFp32: 91128832,
-		nc: 80,
-		imgsz: 640
+	"rtmdet-ins-s": {
+		key: "rtmdet-ins-s",
+		family: "rtmdet-ins",
+		filename: "rtmdet-ins-s.onnx",
+		url: hf(RTMDET_INS_REPO, RTMDET_INS_REV, "models/s/rtmdet-ins_s_640x640.onnx"),
+		bytes: 43236976,
+		sha256: "9cd1787fbf3eb2bd64cc2d8154f41c036f5484b85599e1cbe0227a2dc5a4a08b",
+		input: [640, 640],
+		source: RTMDET_INS_SOURCE
 	},
-	"yolo11n-pose": {
-		key: "yolo11n-pose",
-		task: "pose",
-		variant: "n",
-		filename: "yolo11n-pose.onnx",
-		bytesFp32: 11450368,
-		nc: 1,
-		imgsz: 640
+	"rtmdet-ins-m": {
+		key: "rtmdet-ins-m",
+		family: "rtmdet-ins",
+		filename: "rtmdet-ins-m.onnx",
+		url: hf(RTMDET_INS_REPO, RTMDET_INS_REV, "models/m/rtmdet-ins_m_640x640.onnx"),
+		bytes: 115735979,
+		sha256: "a003bce80316e03467c2c2b483df2d5c0398220c2357a44f9bf985929f7eb052",
+		input: [640, 640],
+		source: RTMDET_INS_SOURCE
 	},
-	"yolo11s-pose": {
-		key: "yolo11s-pose",
-		task: "pose",
-		variant: "s",
-		filename: "yolo11s-pose.onnx",
-		url: "https://huggingface.co/mobilint/YOLO11s-pose/resolve/main/yolo11s-pose.onnx",
-		bytesFp32: 41050112,
-		nc: 1,
-		imgsz: 640
+	"rtmo-t": {
+		key: "rtmo-t",
+		family: "rtmo",
+		filename: "rtmo-t.onnx",
+		url: hf("Xenova/RTMO-t", "f29d13ce5ee291fbe505e9d06a049992f05699dc", "onnx/model.onnx"),
+		bytes: 27360569,
+		sha256: "cb54dd042bf997df86d938721c94238940f2bff98ba8d2ccc834430de5c65c13",
+		input: [416, 416],
+		source: RTMO_SOURCE
 	},
-	"yolo11m-pose": {
-		key: "yolo11m-pose",
-		task: "pose",
-		variant: "m",
-		filename: "yolo11m-pose.onnx",
-		url: "https://huggingface.co/mobilint/YOLO11m-pose/resolve/main/yolo11m-pose.onnx",
-		bytesFp32: 821e5,
-		nc: 1,
-		imgsz: 640
+	"rtmo-s": {
+		key: "rtmo-s",
+		family: "rtmo",
+		filename: "rtmo-s.onnx",
+		url: hf("Xenova/RTMO-s", "d8c526187f341d287753831c9c8b1ecc4855bba1", "onnx/model.onnx"),
+		bytes: 39636400,
+		sha256: "1cd6a3517658903233e9ccb78666554862f57f0944b6886e2048093594aef4e7",
+		input: [640, 640],
+		source: RTMO_SOURCE
 	},
-	"yolo11l-pose": {
-		key: "yolo11l-pose",
-		task: "pose",
-		variant: "l",
-		filename: "yolo11l-pose.onnx",
-		url: "https://huggingface.co/mobilint/YOLO11l-pose/resolve/main/yolo11l-pose.onnx",
-		bytesFp32: 1105e5,
-		nc: 1,
-		imgsz: 640
+	"rtmo-m": {
+		key: "rtmo-m",
+		family: "rtmo",
+		filename: "rtmo-m.onnx",
+		url: hf("Xenova/RTMO-m", "3aba1280472b98ee2bf663482e27e243038d23fe", "onnx/model.onnx"),
+		bytes: 89291929,
+		sha256: "76d82c45e5c4810baf587ecf2638d15cbf7ed196afb2055e977382532021b59e",
+		input: [640, 640],
+		source: RTMO_SOURCE
 	},
-	"yolo11n-obb": {
-		key: "yolo11n-obb",
-		task: "obb",
-		variant: "n",
-		filename: "yolo11n-obb.onnx",
-		bytesFp32: 12048384,
-		nc: 15,
-		imgsz: 1024
+	"selfie-square": {
+		key: "selfie-square",
+		family: "selfie",
+		filename: "selfie-square.onnx",
+		url: hf("onnx-community/mediapipe_selfie_segmentation", "be49485c8e027524be38591817fc5cd31bd9d00e", "onnx/model.onnx"),
+		bytes: 462352,
+		sha256: "3241ac4ad8aa35bdaf33946776db29f7c283a413aa0b0dacb9483594b4531aad",
+		input: [256, 256],
+		source: SELFIE_SOURCE
 	},
-	"yolo11s-obb": {
-		key: "yolo11s-obb",
-		task: "obb",
-		variant: "s",
-		filename: "yolo11s-obb.onnx",
-		bytesFp32: 43253760,
-		nc: 15,
-		imgsz: 1024
-	},
-	"yolo11m-obb": {
-		key: "yolo11m-obb",
-		task: "obb",
-		variant: "m",
-		filename: "yolo11m-obb.onnx",
-		url: "https://huggingface.co/mobilint/YOLO11m-obb/resolve/main/yolo11m-obb.onnx",
-		bytesFp32: 832e5,
-		nc: 15,
-		imgsz: 1024
-	},
-	"yolo11l-obb": {
-		key: "yolo11l-obb",
-		task: "obb",
-		variant: "l",
-		filename: "yolo11l-obb.onnx",
-		url: "https://huggingface.co/mobilint/YOLO11l-obb/resolve/main/yolo11l-obb.onnx",
-		bytesFp32: 111e6,
-		nc: 15,
-		imgsz: 1024
-	},
-	"yolo11n-cls": {
-		key: "yolo11n-cls",
-		task: "classify",
-		variant: "n",
-		filename: "yolo11n-cls.onnx",
-		bytesFp32: 11918848,
-		nc: 1e3,
-		imgsz: 224
-	},
-	"yolo11s-cls": {
-		key: "yolo11s-cls",
-		task: "classify",
-		variant: "s",
-		filename: "yolo11s-cls.onnx",
-		bytesFp32: 42704896,
-		nc: 1e3,
-		imgsz: 224
-	},
-	"yolov8s-worldv2": {
-		key: "yolov8s-worldv2",
-		task: "world",
-		variant: "s",
-		filename: "yolov8s-worldv2.onnx",
-		url: "https://huggingface.co/Instemic/yolo-world-onnx/resolve/main/yolov8s-worldv2.onnx",
-		bytesFp32: 52e6,
-		nc: 80,
-		imgsz: 640
-	},
-	"yolov8m-worldv2": {
-		key: "yolov8m-worldv2",
-		task: "world",
-		variant: "m",
-		filename: "yolov8m-worldv2.onnx",
-		url: "https://huggingface.co/ultralytics/yolov8/resolve/main/yolov8m-worldv2.onnx",
-		bytesFp32: 108e6,
-		nc: 80,
-		imgsz: 640
+	"selfie-landscape": {
+		key: "selfie-landscape",
+		family: "selfie",
+		filename: "selfie-landscape.onnx",
+		url: hf("onnx-community/mediapipe_selfie_segmentation_landscape", "2497d5bec26c626c7b3c4edc6e1fefc21b64f6c3", "onnx/model.onnx"),
+		bytes: 462338,
+		sha256: "7a0adcfdb1715d3b0ff0f61486d8a181c33f4a208343a5abfccbc6540e872d24",
+		input: [256, 144],
+		source: SELFIE_SOURCE
 	}
 };
-const DEFAULT_MODEL_KEY_BY_TASK = {
-	detect: (v) => v === "n" ? "yolo11n" : v === "s" ? "yolo11s" : v === "m" ? "yolo11m" : v === "l" ? "yolo11l" : "yolo11x",
-	segment: (v) => v === "m" ? "yolo11m-seg" : v === "s" ? "yolo11s-seg" : "yolo11n-seg",
-	pose: (v) => v === "l" ? "yolo11l-pose" : v === "m" ? "yolo11m-pose" : v === "s" ? "yolo11s-pose" : "yolo11n-pose",
-	obb: (v) => v === "l" ? "yolo11l-obb" : v === "m" ? "yolo11m-obb" : v === "s" ? "yolo11s-obb" : "yolo11n-obb",
-	classify: (v) => v === "s" ? "yolo11s-cls" : "yolo11n-cls",
-	world: (v) => v === "m" || v === "l" || v === "x" ? "yolov8m-worldv2" : "yolov8s-worldv2"
-};
-/** COCO 80 class names — index order matches every ultralytics COCO export. */
-const YOLO_COCO_CLASSES = [
+/**
+* Resolves the model for a task. `detect` and `segment` share RTMDet-Ins (one forward pass
+* yields both); `matte` picks the landscape Selfie Segmenter for wide frames.
+*/
+function modelKeyFor(task, variant = "s", aspect = 1) {
+	if (task === "pose") return `rtmo-${variant}`;
+	if (task === "matte") return aspect > 1.3 ? "selfie-landscape" : "selfie-square";
+	return `rtmdet-ins-${variant}`;
+}
+/** COCO 80 class names — index order matches the RTMDet-Ins `labels` output. */
+const COCO_CLASSES = [
 	"person",
 	"bicycle",
 	"car",
@@ -2519,25 +2407,10 @@ const YOLO_COCO_CLASSES = [
 	"hair drier",
 	"toothbrush"
 ];
-/** DOTA-v1.0 15 class names — index order matches ultralytics YOLO11-OBB export. */
-const YOLO_DOTA_CLASSES = [
-	"plane",
-	"ship",
-	"storage tank",
-	"baseball diamond",
-	"tennis court",
-	"basketball court",
-	"ground track field",
-	"harbor",
-	"bridge",
-	"large vehicle",
-	"small vehicle",
-	"helicopter",
-	"roundabout",
-	"soccer ball field",
-	"swimming pool"
-];
-function computeIoU$1(boxA, boxB) {
+
+//#endregion
+//#region ../vision/dist/src-Dv7EKzQ2.mjs
+function computeIoU(boxA, boxB) {
 	const xA = Math.max(boxA.originX, boxB.originX);
 	const yA = Math.max(boxA.originY, boxB.originY);
 	const xB = Math.min(boxA.originX + boxA.width, boxB.originX + boxB.width);
@@ -2609,7 +2482,7 @@ var TemporalObjectTracker = class {
 			for (let d = 0; d < detections.length; d++) {
 				const det = detections[d];
 				if (trk.category !== det.category) continue;
-				const iou = computeIoU$1(trk.box, det.boundingBox);
+				const iou = computeIoU(trk.box, det.boundingBox);
 				if (iou >= this._iouThreshold) candidateMatches.push({
 					trackIdx: t,
 					detIdx: d,
@@ -2888,22 +2761,22 @@ async function analyzeSequence(frames, options) {
 	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 detectionTask = taskSet.has("detect") ? "detect" : taskSet.has("segment") ? "segment" : taskSet.has("obb") ? "obb" : null;
+	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, fn) => {
-		const key = runner.modelKeyFor(task);
+	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: YOLO_MODELS[key].bytesFp32,
+			bytes: VISION_MODELS[key].bytes,
 			ms: elapsed
 		};
 		return result;
@@ -2922,19 +2795,13 @@ async function analyzeSequence(frames, options) {
 	};
 	for await (const frame of frames) {
 		let detections = [];
-		if (includeMasks || detectionTask === "segment") {
-			const seg = await runTask("segment", () => runner.segment(frame));
-			if (includeMasks) recordMasks(seg.masks);
-			if (detectionTask === "segment") detections = seg.detections;
-		}
-		if (detectionTask === "detect") detections = await runTask("detect", () => runner.detect(frame));
-		else if (detectionTask === "obb") detections = (await runTask("obb", () => runner.detectObb(frame))).detections.map((d) => ({
-			category: d.category,
-			score: d.score,
-			boundingBox: d.boundingBox
-		}));
-		if (taskSet.has("pose")) await runTask("pose", () => runner.pose(frame));
-		if (taskSet.has("classify")) await runTask("classify", () => runner.classify(frame));
+		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++;
 	}
@@ -3014,463 +2881,374 @@ async function analyzeSequence(frames, options) {
 		masks
 	};
 }
-/** Classification head: [1, nc] logits → softmax → top-5. */
-function decodeClassifyOutput(output, nc) {
-	const count = Math.min(nc, output.length);
-	let max = -Infinity;
-	for (let i = 0; i < count; i++) if (output[i] > max) max = output[i];
-	let sum = 0;
-	const probs = new Float32Array(count);
-	for (let i = 0; i < count; i++) {
-		const p = Math.exp(output[i] - max);
-		probs[i] = p;
-		sum += p;
-	}
-	const inv = sum > 0 ? 1 / sum : 0;
-	for (let i = 0; i < count; i++) probs[i] *= inv;
-	const top5 = [];
-	for (let i = 0; i < Math.min(5, probs.length); i++) {
-		let best = -1;
-		let bestScore = -1;
-		for (let c = 0; c < probs.length; c++) if (probs[c] > bestScore) {
-			bestScore = probs[c];
-			best = c;
-		}
-		if (best < 0) break;
-		top5.push({
-			index: best,
-			score: bestScore
-		});
-		probs[best] = -1;
+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 {
-		top1: top5[0]?.index ?? 0,
-		top1Score: top5[0]?.score ?? 0,
-		top5
+		...PREPROCESS_BY_FAMILY[family],
+		width: input[0],
+		height: input[1]
 	};
 }
-function computeIoU(a, b) {
-	const interX0 = Math.max(a.x0, b.x0);
-	const interY0 = Math.max(a.y0, b.y0);
-	const interX1 = Math.min(a.x1, b.x1);
-	const interY1 = Math.min(a.y1, b.y1);
-	const interArea = Math.max(0, interX1 - interX0) * Math.max(0, interY1 - interY0);
-	if (interArea <= 0) return 0;
-	const unionArea = (a.x1 - a.x0) * (a.y1 - a.y0) + (b.x1 - b.x0) * (b.y1 - b.y0) - interArea;
-	return unionArea > 0 ? interArea / unionArea : 0;
-}
-/**
-* Greedy class-aware NMS: boxes of different classes never suppress each other
-* (matches ultralytics default behavior).
-*/
-function nms(boxes, iouThreshold = .45) {
-	const sorted = [...boxes].sort((a, b) => b.score - a.score);
-	const kept = [];
-	for (const candidate of sorted) {
-		let suppressed = false;
-		for (const k of kept) {
-			if (k.classIndex !== candidate.classIndex) continue;
-			if (computeIoU(k, candidate) > iouThreshold) {
-				suppressed = true;
-				break;
-			}
-		}
-		if (!suppressed) kept.push(candidate);
-	}
-	return kept;
-}
-function decodeYoloBoxes(output, anchors, nc, opts) {
-	const candidates = [];
-	const classFilter = opts.classes ? new Set(opts.classes.map((c) => c.toLowerCase())) : null;
-	for (let a = 0; a < anchors; a++) {
-		let bestScore = -1;
-		let bestClass = -1;
-		for (let c = 0; c < nc; c++) {
-			const score = output[(4 + c) * anchors + a];
-			if (score > bestScore) {
-				bestScore = score;
-				bestClass = c;
-			}
-		}
-		if (bestScore < opts.confidence) continue;
-		if (classFilter && !classFilter.has((opts.classNames[bestClass] ?? "").toLowerCase())) continue;
-		const cx = output[a];
-		const cy = output[anchors + a];
-		const w = output[2 * anchors + a];
-		const h = output[3 * anchors + a];
-		if (w <= 0 || h <= 0) continue;
-		const halfW = w / 2;
-		const halfH = h / 2;
-		candidates.push({
-			x0: cx - halfW,
-			y0: cy - halfH,
-			x1: cx + halfW,
-			y1: cy + halfH,
-			score: bestScore,
-			classIndex: bestClass,
-			anchorIndex: a
-		});
-	}
-	return nms(candidates, opts.iouThreshold);
-}
-/** Maps an NMS-kept box from input space to a core `DetectedObject` in source pixel space. */
-function toDetectedObject(box, opts) {
-	const { scale, dw, dh } = opts.params;
-	const { sourceWidth: sw, sourceHeight: sh } = opts;
-	const x0 = Math.max(0, Math.min(sw, (box.x0 - dw) / scale));
-	const y0 = Math.max(0, Math.min(sh, (box.y0 - dh) / scale));
-	const x1 = Math.max(0, Math.min(sw, (box.x1 - dw) / scale));
-	const y1 = Math.max(0, Math.min(sh, (box.y1 - dh) / scale));
-	const width = Math.max(0, x1 - x0);
-	const height = Math.max(0, y1 - y0);
+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 {
-		category: opts.classNames[box.classIndex] ?? `class_${box.classIndex}`,
-		score: box.score,
-		boundingBox: {
-			originX: x0,
-			originY: y0,
-			width,
-			height,
-			normalizedX: sw > 0 ? x0 / sw : 0,
-			normalizedY: sh > 0 ? y0 / sh : 0,
-			normalizedWidth: sw > 0 ? width / sw : 0,
-			normalizedHeight: sh > 0 ? height / sh : 0
-		}
+		scaleX: scale,
+		scaleY: scale,
+		offsetX: center ? (spec.width - contentW) / 2 : 0,
+		offsetY: center ? (spec.height - contentH) / 2 : 0,
+		inputWidth: spec.width,
+		inputHeight: spec.height
 	};
 }
-/** Full detect-head decode: hidden state → DetectedObject[] (already NMS'd, source pixels). */
-function decodeDetectOutput(output, anchors, nc, opts) {
-	return decodeYoloBoxes(output, anchors, nc, opts).map((box) => toDetectedObject(box, opts));
-}
-/**
-* Letterbox preprocessing + inverse mapping.
-*
-* The YOLO ONNX export consumes a square RGB float tensor (imgsz × imgsz), values / 255,
-* gray (114) padding on the short dimension — the "letterbox". Box/keypoint outputs are
-* in input-pixel space; this module owns the resize and the mapping back to source pixels.
-*/
-const YOLO_LETTERBOX_PAD_VALUE = 114;
-function computeLetterbox(srcW, srcH, imgsz) {
-	const scale = Math.min(imgsz / srcW, imgsz / srcH);
-	const inputWidth = Math.round(srcW * scale);
-	const inputHeight = Math.round(srcH * scale);
+/** Model-input point → source pixel point. */
+function toSourcePoint(x, y, t) {
 	return {
-		scale,
-		dw: (imgsz - inputWidth) / 2,
-		dh: (imgsz - inputHeight) / 2,
-		inputWidth,
-		inputHeight,
-		size: imgsz
+		x: (x - t.offsetX) / t.scaleX,
+		y: (y - t.offsetY) / t.scaleY
 	};
 }
 /**
-* Resizes RGBA -> NCHW float32 tensor with bilinear sampling + gray padding.
-* Layout: [1, 3, imgsz, imgsz], channel stride = imgsz * imgsz.
-* Reuses `out` / `outData` when provided (hot-path frame loop).
+* 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 letterboxToTensor(image, imgsz = 640, out) {
-	const { width: srcW, height: srcH } = image;
-	const params = computeLetterbox(srcW, srcH, imgsz);
-	const { scale, dw, dh, inputWidth, inputHeight } = params;
-	const channelStride = imgsz * imgsz;
-	if (!out || out.length < 3 * channelStride) out = new Float32Array(3 * channelStride);
-	else out.fill(0, 0, 3 * channelStride);
-	const src = image.data;
-	const pad = YOLO_LETTERBOX_PAD_VALUE / 255;
-	const x0 = Math.ceil(dw);
-	const y0 = Math.ceil(dh);
-	const x1 = Math.floor(dw + inputWidth) - 1;
-	const y1 = Math.floor(dh + inputHeight) - 1;
-	const rPlane = out.subarray(0, channelStride);
-	const gPlane = out.subarray(channelStride, 2 * channelStride);
-	const bPlane = out.subarray(2 * channelStride, 3 * channelStride);
-	for (let y = 0; y < imgsz; y++) {
-		const rowBase = y * imgsz;
+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;
-		for (let x = 0; x < imgsz; x++) {
-			let r = pad;
-			let g = pad;
-			let b = pad;
-			if (!paddedRow && x >= x0 && x <= x1) {
-				const sx = (x - dw) / scale;
-				const sy = (y - dh) / scale;
-				const x0s = Math.floor(sx);
-				const y0s = Math.floor(sy);
-				const fx = sx - x0s;
-				const fy = sy - y0s;
-				const x1s = Math.min(srcW - 1, x0s + 1);
-				const y1s = Math.min(srcH - 1, y0s + 1);
-				const i00 = (y0s * srcW + x0s) * 4;
-				const i10 = (y0s * srcW + x1s) * 4;
-				const i01 = (y1s * srcW + x0s) * 4;
-				const i11 = (y1s * srcW + x1s) * 4;
-				const w00 = (1 - fx) * (1 - fy);
-				const w10 = fx * (1 - fy);
-				const w01 = (1 - fx) * fy;
-				const w11 = fx * fy;
-				r = (src[i00] * w00 + src[i10] * w10 + src[i01] * w01 + src[i11] * w11) / 255;
-				g = (src[i00 + 1] * w00 + src[i10 + 1] * w10 + src[i01 + 1] * w01 + src[i11 + 1] * w11) / 255;
-				b = (src[i00 + 2] * w00 + src[i10 + 2] * w10 + src[i01 + 2] * w01 + src[i11 + 2] * w11) / 255;
+		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;
 			}
-			rPlane[rowBase + x] = r;
-			gPlane[rowBase + x] = g;
-			bPlane[rowBase + x] = b;
+			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,
-		params
-	};
-}
-/** Projects the 4 rotated corners (input px) and the axis-aligned extent back to source px. */
-function projectCorners(cx, cy, w, h, angle, opts) {
-	const { scale, dw, dh } = opts.params;
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	const hw = w / 2;
-	const hh = h / 2;
-	const local = [
-		[-hw, -hh],
-		[hw, -hh],
-		[hw, hh],
-		[-hw, hh]
-	];
-	const corners = [];
-	let minX = Infinity;
-	let minY = Infinity;
-	let maxX = -Infinity;
-	let maxY = -Infinity;
-	for (const [lx, ly] of local) {
-		const rx = cx + lx * cos - ly * sin;
-		const ry = cy + lx * sin + ly * cos;
-		const sx = (rx - dw) / scale;
-		const sy = (ry - dh) / scale;
-		corners.push([sx, sy]);
-		if (sx < minX) minX = sx;
-		if (sy < minY) minY = sy;
-		if (sx > maxX) maxX = sx;
-		if (sy > maxY) maxY = sy;
-	}
-	return {
-		corners,
-		minX,
-		minY,
-		maxX,
-		maxY
+		transform
 	};
 }
-function decodeObbOutput(output, anchors, nc, opts) {
-	const angleRow = opts.angleRow ?? 4 + nc;
+/** 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 candidates = [];
-	for (let a = 0; a < anchors; a++) {
-		let bestScore = -1;
-		let bestClass = -1;
-		for (let c = 0; c < nc; c++) {
-			const score = output[(4 + c) * anchors + a];
-			if (score > bestScore) {
-				bestScore = score;
-				bestClass = c;
+	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
+				}
 			}
-		}
-		if (bestScore < opts.confidence) continue;
-		if (classFilter && !classFilter.has((opts.classNames[bestClass] ?? "").toLowerCase())) continue;
-		const cx = output[a];
-		const cy = output[anchors + a];
-		const w = output[2 * anchors + a];
-		const h = output[3 * anchors + a];
-		if (w <= 0 || h <= 0) continue;
-		const angle = output[angleRow * anchors + a];
-		if (!Number.isFinite(angle)) continue;
-		candidates.push({
-			x0: cx - w / 2,
-			y0: cy - h / 2,
-			x1: cx + w / 2,
-			y1: cy + h / 2,
-			score: bestScore,
-			classIndex: bestClass,
-			anchorIndex: a,
-			angle
 		});
 	}
-	const kept = nms(candidates, opts.iouThreshold);
-	const detections = [];
-	for (const box of kept) {
-		const cand = box;
-		const cx = output[cand.anchorIndex];
-		const cy = output[anchors + cand.anchorIndex];
-		const w = output[2 * anchors + cand.anchorIndex];
-		const h = output[3 * anchors + cand.anchorIndex];
-		const { corners, minX, minY, maxX, maxY } = projectCorners(cx, cy, w, h, cand.angle, opts);
-		const sw = opts.sourceWidth;
-		const sh = opts.sourceHeight;
-		const originX = Math.max(0, Math.min(sw, minX));
-		const originY = Math.max(0, Math.min(sh, minY));
-		const width = Math.max(0, Math.min(sw, maxX) - originX);
-		const height = Math.max(0, Math.min(sh, maxY) - originY);
-		detections.push({
-			category: opts.classNames[cand.classIndex] ?? `class_${cand.classIndex}`,
-			classIndex: cand.classIndex,
-			score: cand.score,
-			boundingBox: {
-				originX,
-				originY,
-				width,
-				height,
-				normalizedX: sw > 0 ? originX / sw : 0,
-				normalizedY: sh > 0 ? originY / sh : 0,
-				normalizedWidth: sw > 0 ? width / sw : 0,
-				normalizedHeight: sh > 0 ? height / sh : 0,
-				angle: cand.angle
-			},
-			corners
+	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 };
+	return {
+		detections,
+		masks
+	};
 }
-function decodePoseOutput(output, anchors, opts) {
-	const { scale, dw, dh } = opts.params;
-	const { sourceWidth: sw, sourceHeight: sh } = opts;
+/**
+* Probability → 0..255 alpha. A hard threshold when `feather` is 0, otherwise a linear ramp
+* across `[threshold − feather, threshold + feather]` for anti-aliased edges.
+*/
+function probabilityToAlpha(threshold, feather) {
+	if (feather <= 0) return (p) => p > threshold ? 255 : 0;
+	const lo = threshold - feather;
+	const inv = 255 / (2 * feather);
+	return (p) => p <= lo ? 0 : p >= threshold + feather ? 255 : (p - lo) * inv;
+}
+function clamp$1(v, lo, hi) {
+	return v < lo ? lo : v > hi ? hi : v;
+}
+const COCO17_KEYPOINT_COUNT = 17;
+/** Keypoint visibility at which a joint counts as seen. */
+const VISIBLE = .3;
+function decodeRtmo(out, opts) {
+	const { sourceWidth: sw, sourceHeight: sh, transform } = opts;
+	const stride = out.keypointStride;
 	const people = [];
-	for (let a = 0; a < anchors; a++) {
-		const score = output[4 * anchors + a];
-		if (score < opts.confidence) continue;
-		const cx = output[a];
-		const cy = output[anchors + a];
-		const w = output[2 * anchors + a];
-		const h = output[3 * anchors + a];
-		if (w <= 0 || h <= 0) continue;
-		const x0 = Math.max(0, Math.min(sw, (cx - w / 2 - dw) / scale));
-		const y0 = Math.max(0, Math.min(sh, (cy - h / 2 - dh) / scale));
-		const x1 = Math.max(0, Math.min(sw, (cx + w / 2 - dw) / scale));
-		const y1 = Math.max(0, Math.min(sh, (cy + h / 2 - dh) / scale));
-		const boxW = Math.max(0, x1 - x0);
-		const boxH = Math.max(0, y1 - y0);
+	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$2(p0.x, 0, sw);
+		const y0 = clamp$2(p0.y, 0, sh);
+		const width = clamp$2(p1.x, 0, sw) - x0;
+		const height = clamp$2(p1.y, 0, sh) - y0;
+		if (width <= 0 || height <= 0) continue;
 		const keypoints = [];
-		for (let k = 0; k < 17; k++) {
-			const kx = Math.max(0, Math.min(sw, (output[(5 + 3 * k) * anchors + a] - dw) / scale));
-			const ky = Math.max(0, Math.min(sh, (output[(6 + 3 * k) * anchors + a] - dh) / scale));
-			const vis = output[(7 + 3 * k) * anchors + a];
+		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: kx,
-				y: ky,
-				visibility: Math.max(0, Math.min(1, vis))
+				x: clamp$2(p.x, 0, sw),
+				y: clamp$2(p.y, 0, sh),
+				visibility: clamp$2(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: boxW,
-				height: boxH,
-				normalizedX: sw > 0 ? x0 / sw : 0,
-				normalizedY: sh > 0 ? y0 / sh : 0,
-				normalizedWidth: sw > 0 ? boxW / sw : 0,
-				normalizedHeight: sh > 0 ? boxH / sh : 0
+				width,
+				height,
+				normalizedX: x0 / sw,
+				normalizedY: y0 / sh,
+				normalizedWidth: width / sw,
+				normalizedHeight: height / sh
 			},
 			keypoints
 		});
 	}
 	people.sort((a, b) => b.score - a.score);
-	return { people };
+	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$2(v, lo, hi) {
+	return v < lo ? lo : v > hi ? hi : v;
 }
 /**
-* Instance segmentation decode.
-*
-* Head:  [1, 4 + nc + 32, 8400]  — the 32 trailing rows are per-detect mask coefficients.
-* Proto: [1, 32, protoDim, protoDim] (protoDim = imgsz / 4, e.g. 160 at 640).
-*
-* Per kept detection:  mask = sigmoid(Σ coeff_c · proto_c) → threshold 0.5, then bilinear
-* upscaled from the 160-grid directly into the ORIGINAL source frame (letterbox-inverse),
-* restricted to the detection box so masks stay tight and cheap.
+* 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 decodeSegmentOutput(output, proto, anchors, nc, protoDim, opts) {
-	const kept = decodeYoloBoxes(output, anchors, nc, opts);
-	const detections = kept.map((box) => toDetectedObject(box, opts));
-	const masks = [];
-	const { scale, dw, dh, size } = opts.params;
+function isDuplicate(a, b, iou) {
+	if (computeIoU(a.boundingBox, b.boundingBox) > iou) return true;
+	const scale = Math.sqrt(a.boundingBox.width * a.boundingBox.height);
+	let sum = 0;
+	let n = 0;
+	for (let k = 0; k < a.keypoints.length; k++) {
+		const ka = a.keypoints[k];
+		const kb = b.keypoints[k];
+		if (ka.visibility < VISIBLE || kb.visibility < VISIBLE) continue;
+		sum += Math.hypot(ka.x - kb.x, ka.y - kb.y);
+		n++;
+	}
+	return n >= 3 && sum / n < .1 * scale;
+}
+function decodeSelfie(alphas, matteWidth, matteHeight, opts) {
 	const { sourceWidth: sw, sourceHeight: sh } = opts;
-	const maskThreshold = opts.maskThreshold ?? .5;
-	const feather = opts.featherRadius !== void 0 ? opts.featherRadius : .05;
-	const maskLogit = Math.log(maskThreshold / (1 - maskThreshold));
-	const tMin = maskThreshold - feather;
-	const tMax = maskThreshold + feather;
-	const invTwoFeather = feather > 0 ? 1 / (2 * feather) : 0;
-	for (let i = 0; i < kept.length; i++) {
-		const box = kept[i];
-		const det = detections[i];
-		const coeffBase = (4 + nc) * anchors + box.anchorIndex;
-		const step = anchors;
-		const padPx = 8;
-		const sx0 = Math.max(0, Math.floor((box.x0 - dw) / scale) - padPx);
-		const sy0 = Math.max(0, Math.floor((box.y0 - dh) / scale) - padPx);
-		const sx1 = Math.min(sw - 1, Math.ceil((box.x1 - dw) / scale) + padPx);
-		const sy1 = Math.min(sh - 1, Math.ceil((box.y1 - dh) / scale) + padPx);
-		if (sx1 < sx0 || sy1 < sy0) continue;
-		const mask = new Uint8Array(sw * sh);
-		const inv = protoDim / size;
-		let area = 0;
-		for (let sy = sy0; sy <= sy1; sy++) {
-			const gyy = (dh + sy * scale) * inv;
-			const gy0 = Math.floor(gyy);
-			const fy = gyy - gy0;
-			const gy1 = Math.min(protoDim - 1, gy0 + 1);
-			const maskRow = sy * sw;
-			for (let sx = sx0; sx <= sx1; sx++) {
-				const gxx = (dw + sx * scale) * inv;
-				const gx0 = Math.floor(gxx);
-				const fx = gxx - gx0;
-				const gx1 = Math.min(protoDim - 1, gx0 + 1);
-				let acc = 0;
-				for (let c = 0; c < 32; c++) {
-					const coeff = output[coeffBase + c * step];
-					if (coeff === 0) continue;
-					const rowBase = c * protoDim * protoDim;
-					const v00 = proto[rowBase + gy0 * protoDim + gx0];
-					const v10 = proto[rowBase + gy0 * protoDim + gx1];
-					const v01 = proto[rowBase + gy1 * protoDim + gx0];
-					const v11 = proto[rowBase + gy1 * protoDim + gx1];
-					const interp = v00 * (1 - fx) * (1 - fy) + v10 * fx * (1 - fy) + v01 * (1 - fx) * fy + v11 * fx * fy;
-					acc += coeff * interp;
-				}
-				if (feather <= 0) {
-					if (acc > maskLogit) {
-						mask[maskRow + sx] = 255;
-						area++;
-					}
-				} else {
-					const alpha = acc > 16 ? 1 : acc < -16 ? 0 : 1 / (1 + Math.exp(-acc));
-					let alphaNorm = 0;
-					if (alpha >= tMax) alphaNorm = 1;
-					else if (alpha > tMin) alphaNorm = (alpha - tMin) * invTwoFeather;
-					const alphaOut = Math.round(alphaNorm * 255);
-					if (alphaOut > 0) {
-						mask[maskRow + sx] = alphaOut;
-						area += alphaNorm;
-					}
-				}
-			}
+	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;
 		}
-		area = Math.round(area);
-		if (area === 0) continue;
-		masks.push({
-			category: det.category,
-			mask,
-			width: sw,
-			height: sh,
-			area,
-			coverage: sw * sh > 0 ? area / (sw * sh) : 0,
-			detectionIndex: i
-		});
 	}
 	return {
-		detections,
-		masks
+		mask,
+		width: sw,
+		height: sh,
+		coverage: sw * sh > 0 ? sum / (255 * sw * sh) : 0
 	};
 }
-/** COCO-17 keypoint indices for YOLO pose outputs (matches YOLO_POSE_KEYPOINTS order). */
-const POSE_LANDMARKS_YOLO = {
+/** COCO-17 keypoint indices (RTMO output order). */
+const COCO17_KEYPOINTS = {
 	NOSE: 0,
 	LEFT_EYE: 1,
 	RIGHT_EYE: 2,
@@ -3489,7 +3267,7 @@ const POSE_LANDMARKS_YOLO = {
 	LEFT_ANKLE: 15,
 	RIGHT_ANKLE: 16
 };
-const YOLO_POSE_KEYPOINT_NAMES = [
+const COCO17_KEYPOINT_NAMES = [
 	"nose",
 	"leftEye",
 	"rightEye",
@@ -3509,10 +3287,10 @@ const YOLO_POSE_KEYPOINT_NAMES = [
 	"rightAnkle"
 ];
 /** COCO-17 skeleton bones for the WebGPU skeleton renderer (indices above). */
-const YOLO_COCO17_BONES = [
+const COCO17_BONES = [
 	{
-		from: POSE_LANDMARKS_YOLO.NOSE,
-		to: POSE_LANDMARKS_YOLO.LEFT_SHOULDER,
+		from: COCO17_KEYPOINTS.NOSE,
+		to: COCO17_KEYPOINTS.LEFT_SHOULDER,
 		color: [
 			0,
 			1,
@@ -3521,8 +3299,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.NOSE,
-		to: POSE_LANDMARKS_YOLO.RIGHT_SHOULDER,
+		from: COCO17_KEYPOINTS.NOSE,
+		to: COCO17_KEYPOINTS.RIGHT_SHOULDER,
 		color: [
 			0,
 			1,
@@ -3531,8 +3309,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.LEFT_SHOULDER,
-		to: POSE_LANDMARKS_YOLO.RIGHT_SHOULDER,
+		from: COCO17_KEYPOINTS.LEFT_SHOULDER,
+		to: COCO17_KEYPOINTS.RIGHT_SHOULDER,
 		color: [
 			1,
 			0,
@@ -3541,8 +3319,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.LEFT_SHOULDER,
-		to: POSE_LANDMARKS_YOLO.LEFT_ELBOW,
+		from: COCO17_KEYPOINTS.LEFT_SHOULDER,
+		to: COCO17_KEYPOINTS.LEFT_ELBOW,
 		color: [
 			1,
 			.333,
@@ -3551,8 +3329,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.LEFT_ELBOW,
-		to: POSE_LANDMARKS_YOLO.LEFT_WRIST,
+		from: COCO17_KEYPOINTS.LEFT_ELBOW,
+		to: COCO17_KEYPOINTS.LEFT_WRIST,
 		color: [
 			1,
 			.667,
@@ -3561,8 +3339,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.RIGHT_SHOULDER,
-		to: POSE_LANDMARKS_YOLO.RIGHT_ELBOW,
+		from: COCO17_KEYPOINTS.RIGHT_SHOULDER,
+		to: COCO17_KEYPOINTS.RIGHT_ELBOW,
 		color: [
 			1,
 			1,
@@ -3571,8 +3349,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.RIGHT_ELBOW,
-		to: POSE_LANDMARKS_YOLO.RIGHT_WRIST,
+		from: COCO17_KEYPOINTS.RIGHT_ELBOW,
+		to: COCO17_KEYPOINTS.RIGHT_WRIST,
 		color: [
 			.667,
 			1,
@@ -3581,8 +3359,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.LEFT_SHOULDER,
-		to: POSE_LANDMARKS_YOLO.LEFT_HIP,
+		from: COCO17_KEYPOINTS.LEFT_SHOULDER,
+		to: COCO17_KEYPOINTS.LEFT_HIP,
 		color: [
 			.333,
 			1,
@@ -3591,8 +3369,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.RIGHT_SHOULDER,
-		to: POSE_LANDMARKS_YOLO.RIGHT_HIP,
+		from: COCO17_KEYPOINTS.RIGHT_SHOULDER,
+		to: COCO17_KEYPOINTS.RIGHT_HIP,
 		color: [
 			0,
 			1,
@@ -3601,8 +3379,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.LEFT_HIP,
-		to: POSE_LANDMARKS_YOLO.RIGHT_HIP,
+		from: COCO17_KEYPOINTS.LEFT_HIP,
+		to: COCO17_KEYPOINTS.RIGHT_HIP,
 		color: [
 			0,
 			1,
@@ -3611,8 +3389,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.LEFT_HIP,
-		to: POSE_LANDMARKS_YOLO.LEFT_KNEE,
+		from: COCO17_KEYPOINTS.LEFT_HIP,
+		to: COCO17_KEYPOINTS.LEFT_KNEE,
 		color: [
 			0,
 			1,
@@ -3621,8 +3399,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.LEFT_KNEE,
-		to: POSE_LANDMARKS_YOLO.LEFT_ANKLE,
+		from: COCO17_KEYPOINTS.LEFT_KNEE,
+		to: COCO17_KEYPOINTS.LEFT_ANKLE,
 		color: [
 			0,
 			1,
@@ -3631,8 +3409,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.RIGHT_HIP,
-		to: POSE_LANDMARKS_YOLO.RIGHT_KNEE,
+		from: COCO17_KEYPOINTS.RIGHT_HIP,
+		to: COCO17_KEYPOINTS.RIGHT_KNEE,
 		color: [
 			0,
 			.667,
@@ -3641,8 +3419,8 @@ const YOLO_COCO17_BONES = [
 		]
 	},
 	{
-		from: POSE_LANDMARKS_YOLO.RIGHT_KNEE,
-		to: POSE_LANDMARKS_YOLO.RIGHT_ANKLE,
+		from: COCO17_KEYPOINTS.RIGHT_KNEE,
+		to: COCO17_KEYPOINTS.RIGHT_ANKLE,
 		color: [
 			0,
 			.333,
@@ -3651,35 +3429,18 @@ const YOLO_COCO17_BONES = [
 		]
 	}
 ];
-/** Mapping from MediaPipe 33-pose indices to YOLO COCO-17 (named props survive unchanged). */
-const MEDIAPIPE_TO_YOLO_POSE_INDEX = {
-	0: 0,
-	11: 5,
-	12: 6,
-	13: 7,
-	14: 8,
-	15: 9,
-	16: 10,
-	23: 11,
-	24: 12,
-	25: 13,
-	26: 14,
-	27: 15,
-	28: 16
-};
 /**
-* WebGPU skeleton renderer for YOLO pose results.
+* WebGPU skeleton renderer for pose results.
 *
 * Rasterizes the primary person's COCO-17 keypoints into an OpenPose-style
-* conditioning texture natively in VRAM — same compute pipeline as the MediaPipe
-* renderer, with the COCO-17 bone set instead of the 33-point OpenPose set.
+* 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 = YOLO_COCO17_BONES) {
+	renderToTexture(keypoints, options, bones = COCO17_BONES) {
 		return this.pipeline.execute(keypoints, options, bones);
 	}
 	destroy() {
@@ -3698,7 +3459,7 @@ var SegmentationTexturePool = class {
 		if (existing) existing.destroy();
 		const format = options.format ?? "rgba8unorm";
 		const texture = this.device.createTexture({
-			label: options.label ?? `Yolo_Segmentation_${key}`,
+			label: options.label ?? `vision_segmentation_${key}`,
 			size: [
 				options.width,
 				options.height,
@@ -3756,18 +3517,19 @@ function getDefaultModelsDir() {
 	return resolve(homedir(), ".cache/gitframes/models");
 }
 /**
-* Lazy YOLO model store. Constructor performs ZERO I/O; the only entry that can hit the
+* 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),
-* and verified files on disk are reused across processes.
-*
-* Mirrors the proven mechanics of the old MediaPipe model manager (atomic temp+rename,
-* size verification, `GITFRAMES_MODELS_DIR` override) minus its eager constructor downloads.
+* downloads are written atomically (temp + rename), and verified files on disk are reused
+* across processes.
 */
-var YoloModelStore = class YoloModelStore$1 {
+var VisionModelStore = class {
 	_modelsDir;
 	_baseUrl;
 	_timeoutMs;
+	_retries;
+	_retryDelayMs;
+	_verify;
 	_fetch;
 	_onProgress;
 	_inflight = /* @__PURE__ */ new Map();
@@ -3775,8 +3537,11 @@ var YoloModelStore = class YoloModelStore$1 {
 	_status = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this._modelsDir = options.modelsDir ? resolve(options.modelsDir) : getDefaultModelsDir();
-		this._baseUrl = options.baseUrl ?? process.env.GITFRAMES_YOLO_BASE_URL ?? DEFAULT_YOLO_BASE_URL;
+		this._baseUrl = options.baseUrl ?? process.env.GITFRAMES_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;
 	}
@@ -3784,22 +3549,24 @@ var YoloModelStore = class YoloModelStore$1 {
 		return this._modelsDir;
 	}
 	pathFor(key) {
-		return join(this._modelsDir, YOLO_MODELS[key].filename);
+		return join(this._modelsDir, VISION_MODELS[key].filename);
 	}
 	descriptor(key) {
-		return YOLO_MODELS[key];
+		return VISION_MODELS[key];
 	}
-	/**
-	* Smallest file we trust as a cached model. Every YOLO11 export in the registry
-	* ships well above 1 MB (smallest is yolo11n-cls ≈ 1.2 MB); a smaller file is a
-	* partial/stub write (e.g. a 4 KiB test fixture) and must be re-downloaded.
-	*/
-	static MIN_VALID_MODEL_BYTES = 512 * 1024;
+	/** 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 {
-			return statSync(targetPath).size >= YoloModelStore$1.MIN_VALID_MODEL_BYTES;
+			const size = statSync(targetPath).size;
+			return this._verify ? size === VISION_MODELS[key].bytes : size > 0;
 		} catch {
 			return false;
 		}
@@ -3810,13 +3577,6 @@ var YoloModelStore = class YoloModelStore$1 {
 		this._status.set(key, "pending");
 		await unlink(this.pathFor(key)).catch(() => void 0);
 	}
-	/** Direct download helper for arbitrary model URLs, respecting injected fetch. */
-	async fetchDirect(url) {
-		const res = await this._fetch(url);
-		if (!res.ok) throw new Error(`Failed to fetch model from ${url}: ${res.statusText}`);
-		const buf = await res.arrayBuffer();
-		return new Uint8Array(buf);
-	}
 	status(key) {
 		return this._status.get(key) ?? "pending";
 	}
@@ -3843,7 +3603,7 @@ var YoloModelStore = class YoloModelStore$1 {
 	}
 	/** Explicit warm-up — fetch multiple models ahead of use (agents, renderers). */
 	async preload(keys) {
-		await Promise.all(keys.map((key) => this.ensure(key)));
+		await Promise.all([...new Set(keys)].map((key) => this.ensure(key)));
 	}
 	async load(key) {
 		const targetPath = this.pathFor(key);
@@ -3851,19 +3611,15 @@ var YoloModelStore = class YoloModelStore$1 {
 			this._status.set(key, "ready");
 			return this.readBuffer(key, targetPath);
 		}
-		const desc = YOLO_MODELS[key];
-		const downloadUrl = desc.url ?? `${this._baseUrl}${desc.filename}`;
+		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 response = await this._fetch(downloadUrl, { signal: this._timeoutMs ? AbortSignal.timeout(this._timeoutMs) : void 0 });
-			if (!response.ok) throw new Error(`Failed to download YOLO model '${key}' from ${downloadUrl}: HTTP ${response.status} ${response.statusText}`);
-			const totalBytes = Number(response.headers.get("content-length") ?? 0);
-			const arrayBuffer = await response.arrayBuffer();
-			const buffer = new Uint8Array(arrayBuffer);
-			if (buffer.byteLength === 0) throw new Error(`Downloaded YOLO model '${key}' is empty (0 bytes).`);
-			if (this._onProgress) this._onProgress(key, buffer.byteLength, totalBytes || buffer.byteLength);
+			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);
@@ -3875,6 +3631,36 @@ var YoloModelStore = class YoloModelStore$1 {
 			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}).`);
+	}
 	readBuffer(key, targetPath) {
 		const fileBuffer = readFileSync(targetPath);
 		const buffer = new Uint8Array(fileBuffer.buffer, fileBuffer.byteOffset, fileBuffer.byteLength);
@@ -3918,7 +3704,7 @@ var NodeSessionProvider = class {
 		});
 		return this.ortPromise;
 	}
-	async createSession(modelBytes, _opts) {
+	async createSession(modelBytes) {
 		const ort = await this.ort();
 		const session = await ort.InferenceSession.create(modelBytes, {
 			executionProviders: ["cpu"],
@@ -3926,12 +3712,7 @@ var NodeSessionProvider = class {
 		});
 		return {
 			run: async (input) => {
-				const inputs = Array.isArray(input) ? input : [input];
-				const feeds = {};
-				for (const inp of inputs) {
-					const inputName = session.inputNames.includes(inp.name) ? inp.name : session.inputNames[0] ?? inp.name;
-					feeds[inputName] = new ort.Tensor("float32", inp.data, [...inp.dims]);
-				}
+				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] = {
@@ -3946,48 +3727,33 @@ var NodeSessionProvider = class {
 		};
 	}
 };
-const YOLO_ANCHORS_FOR_SIZE = {
-	320: 2100,
-	640: 8400,
-	1024: 21504,
-	1280: 33600
-};
 /**
-* Lazy YOLO11 runner.
+* Lazy vision runner.
 *
-* `create()` performs ZERO I/O: no model downloads, no sessions, no environment patching.
-* Each inference method (`detect` / `segment` / `pose` / `classify`) downloads its model
-* and warms its session on FIRST USE ONLY, then reuses them for the process lifetime.
+* `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 YoloVisionRunner = class YoloVisionRunner$1 {
+var VisionRunner = class VisionRunner$1 {
 	variant;
-	imgsz;
 	confidence;
-	iouThreshold;
 	classes;
-	enableWorld;
-	prompts;
-	customModel;
 	maskThreshold;
 	featherRadius;
 	_store;
 	_provider;
 	_sessions = /* @__PURE__ */ new Map();
 	_tensorScratch = /* @__PURE__ */ new Map();
-	_customSessionPromise;
+	/** One RTMDet-Ins pass per frame buffer, shared by detect() and segment(). */
+	_instancePass;
 	constructor(options) {
-		this.variant = options.variant ?? "n";
-		this.imgsz = options.imgsz ?? 640;
-		this.confidence = options.confidence ?? .25;
-		this.iouThreshold = options.iouThreshold ?? .45;
+		this.variant = options.variant ?? "s";
+		this.confidence = options.confidence ?? .3;
 		this.classes = options.classes;
-		this.enableWorld = options.enableWorld;
-		this.prompts = options.prompts;
-		this.customModel = options.customModel;
 		this.maskThreshold = options.maskThreshold ?? .5;
 		this.featherRadius = options.featherRadius;
-		this._store = new YoloModelStore({
+		this._store = options.store ?? new VisionModelStore({
 			modelsDir: options.modelsDir,
 			baseUrl: options.baseUrl,
 			timeoutMs: options.timeoutMs,
@@ -3997,7 +3763,7 @@ var YoloVisionRunner = class YoloVisionRunner$1 {
 	}
 	/** Cheap: no downloads, no sessions, no side effects. */
 	static create(options = {}) {
-		return new YoloVisionRunner$1(options);
+		return new VisionRunner$1(options);
 	}
 	get modelsDir() {
 		return this._store.modelsDir;
@@ -4005,291 +3771,144 @@ var YoloVisionRunner = class YoloVisionRunner$1 {
 	/** Every registry model keyed to its current download state (downloaded → "ready"). */
 	get downloadStatus() {
 		const statuses = /* @__PURE__ */ new Map();
-		for (const key of Object.keys(YOLO_MODELS)) statuses.set(key, "pending");
+		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;
 	}
-	modelKeyFor(task) {
-		return DEFAULT_MODEL_KEY_BY_TASK[task](this.variant);
-	}
-	/** Explicit warm-up: downloads + sessions for the given tasks, ahead of first use. */
-	async preload(tasks) {
-		if (this.customModel) {
-			await this.customSession();
-			return;
-		}
-		const defaultTasks = this.enableWorld || this.prompts ? [
-			"world",
-			"segment",
-			"pose"
-		] : [
-			"detect",
-			"segment",
-			"pose"
-		];
-		const keys = (tasks ?? defaultTasks).map((t) => this.modelKeyFor(t));
-		await this._store.preload(keys);
-		await Promise.all(keys.map((key) => this.session(key)));
+	/** 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) {
-		if (this.customModel && (!this.customModel.task || this.customModel.task === "detect" || this.customModel.task === "world")) return this.detectCustom(image);
-		if (this.enableWorld || this.prompts) return this.detectWorld(image, this.prompts);
-		const key = this.modelKeyFor("detect");
-		const session = await this.session(key);
-		const { tensor, params } = this.prepareInput(image, key);
-		const preds = pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				this.imgsz,
-				this.imgsz
-			]
-		}), 3);
-		return decodeDetectOutput(preds.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[this.imgsz] ?? 8400, YOLO_MODELS[key].nc, this.decodeOptions(image, params));
-	}
-	async detectWorld(image, prompts) {
-		const activePrompts = prompts ?? this.prompts ?? YOLO_COCO_CLASSES;
-		const key = this.modelKeyFor("world");
-		const session = await this.session(key);
-		const { tensor, params } = this.prepareInput(image, key);
-		const txtFeats = new Float32Array(activePrompts.length * 512);
-		for (let c = 0; c < activePrompts.length; c++) txtFeats.set(encodePromptEmbedding(activePrompts[c]), c * 512);
-		const preds = pickByDims(await session.run([{
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				this.imgsz,
-				this.imgsz
-			]
-		}, {
-			name: "txt_feats",
-			data: txtFeats,
-			dims: [
-				1,
-				activePrompts.length,
-				512
-			]
-		}]), 3);
-		return decodeDetectOutput(preds.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[this.imgsz] ?? 8400, activePrompts.length, {
-			...this.decodeOptions(image, params, "world"),
-			classNames: activePrompts
-		});
+		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) {
-		if (this.customModel && this.customModel.task === "segment") return this.segmentCustom(image);
-		const key = this.modelKeyFor("segment");
-		const session = await this.session(key);
-		const { tensor, params } = this.prepareInput(image, key);
-		const outputs = await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				this.imgsz,
-				this.imgsz
-			]
-		});
-		const preds = pickByDims(outputs, 3);
-		const proto = pickByDims(outputs, 4);
-		const protoDim = proto.dims[2] ?? proto.dims[1] ?? 160;
-		return decodeSegmentOutput(preds.data, proto.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[this.imgsz] ?? 8400, YOLO_MODELS[key].nc, protoDim, this.decodeOptions(image, params));
+		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) {
-		if (this.customModel && this.customModel.task === "pose") return this.poseCustom(image);
 		const key = this.modelKeyFor("pose");
-		const session = await this.session(key);
-		const { tensor, params } = this.prepareInput(image, key);
-		const preds = pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				this.imgsz,
-				this.imgsz
-			]
-		}), 3);
-		return decodePoseOutput(preds.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[this.imgsz] ?? 8400, {
+		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,
-			params,
+			transform,
 			sourceWidth: image.width,
 			sourceHeight: image.height
 		});
 	}
-	async detectObb(image) {
-		if (this.customModel && this.customModel.task === "obb") return this.obbCustom(image);
-		const key = this.modelKeyFor("obb");
-		const session = await this.session(key);
-		const modelImgsz = YOLO_MODELS[key].imgsz;
-		const { tensor, params } = this.prepareInput(image, key);
-		const preds = pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				modelImgsz,
-				modelImgsz
-			]
-		}), 3);
-		return decodeObbOutput(preds.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[modelImgsz] ?? 21504, YOLO_MODELS[key].nc, this.decodeOptions(image, params, "obb"));
-	}
-	async classify(image) {
-		if (this.customModel && this.customModel.task === "classify") return this.classifyCustom(image);
-		const key = this.modelKeyFor("classify");
-		const session = await this.session(key);
-		const modelImgsz = YOLO_MODELS[key].imgsz;
-		const { tensor } = letterboxToTensor(image, modelImgsz);
-		return decodeClassifyOutput(pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				modelImgsz,
-				modelImgsz
-			]
-		}), 2).data, YOLO_MODELS[key].nc);
+	/** 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();
-		if (this._customSessionPromise) {
-			this._customSessionPromise.then((session) => session.release()).catch(() => void 0);
-			this._customSessionPromise = void 0;
-		}
+		this._instancePass = void 0;
 		this._store.clearMemoryCache();
 	}
-	async detectCustom(image) {
-		if (!this.customModel) throw new Error("No custom model configured");
-		const session = await this.customSession();
-		const imgsz = this.customModel.imgsz ?? this.imgsz;
-		const scratch = new Float32Array(3 * imgsz * imgsz);
-		const { tensor, params } = letterboxToTensor(normalizeImage(image), imgsz, scratch);
-		const preds = pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				imgsz,
-				imgsz
-			]
-		}), 3);
-		const anchors = preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[imgsz] ?? 8400;
-		return decodeDetectOutput(preds.data, anchors, this.customModel.classes.length, {
-			...this.decodeOptions(image, params),
-			classNames: this.customModel.classes
-		});
-	}
-	async segmentCustom(image) {
-		if (!this.customModel) throw new Error("No custom model configured");
-		const session = await this.customSession();
-		const imgsz = this.customModel.imgsz ?? this.imgsz;
-		const scratch = new Float32Array(3 * imgsz * imgsz);
-		const { tensor, params } = letterboxToTensor(normalizeImage(image), imgsz, scratch);
-		const outputs = await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				imgsz,
-				imgsz
-			]
+	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
+				}
+			};
 		});
-		const preds = pickByDims(outputs, 3);
-		const proto = pickByDims(outputs, 4);
-		const protoDim = proto.dims[2] ?? proto.dims[1] ?? 160;
-		return decodeSegmentOutput(preds.data, proto.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[imgsz] ?? 8400, this.customModel.classes.length, protoDim, {
-			...this.decodeOptions(image, params),
-			classNames: this.customModel.classes
+		this._instancePass = {
+			frame: image.data,
+			result
+		};
+		result.catch(() => {
+			if (this._instancePass?.result === result) this._instancePass = void 0;
 		});
+		return result;
 	}
-	async poseCustom(image) {
-		if (!this.customModel) throw new Error("No custom model configured");
-		const session = await this.customSession();
-		const imgsz = this.customModel.imgsz ?? this.imgsz;
-		const scratch = new Float32Array(3 * imgsz * imgsz);
-		const { tensor, params } = letterboxToTensor(normalizeImage(image), imgsz, scratch);
-		const preds = pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				imgsz,
-				imgsz
-			]
-		}), 3);
-		return decodePoseOutput(preds.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[imgsz] ?? 8400, {
+	instanceDecodeOptions(image, transform) {
+		return {
 			confidence: this.confidence,
-			params,
+			classes: this.classes,
+			classNames: COCO_CLASSES,
+			transform,
 			sourceWidth: image.width,
-			sourceHeight: image.height
-		});
-	}
-	async obbCustom(image) {
-		if (!this.customModel) throw new Error("No custom model configured");
-		const session = await this.customSession();
-		const imgsz = this.customModel.imgsz ?? this.imgsz;
-		const scratch = new Float32Array(3 * imgsz * imgsz);
-		const { tensor, params } = letterboxToTensor(normalizeImage(image), imgsz, scratch);
-		const preds = pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				imgsz,
-				imgsz
-			]
-		}), 3);
-		return decodeObbOutput(preds.data, preds.dims[2] ?? YOLO_ANCHORS_FOR_SIZE[imgsz] ?? 21504, this.customModel.classes.length, {
-			...this.decodeOptions(image, params, "obb"),
-			classNames: this.customModel.classes
-		});
+			sourceHeight: image.height,
+			maskThreshold: this.maskThreshold,
+			...this.featherRadius !== void 0 ? { featherRadius: this.featherRadius } : {}
+		};
 	}
-	async classifyCustom(image) {
-		if (!this.customModel) throw new Error("No custom model configured");
-		const session = await this.customSession();
-		const imgsz = this.customModel.imgsz ?? 224;
-		const { tensor } = letterboxToTensor(image, imgsz);
-		return decodeClassifyOutput(pickByDims(await session.run({
-			name: "images",
-			data: tensor,
-			dims: [
-				1,
-				3,
-				imgsz,
-				imgsz
-			]
-		}), 2).data, this.customModel.classes.length);
-	}
-	customSession() {
-		if (!this.customModel) throw new Error("No customModel specified in YoloVisionRunner options");
-		if (!this._customSessionPromise) {
-			const cm = this.customModel;
-			const imgsz = cm.imgsz ?? this.imgsz;
-			this._customSessionPromise = this.loadCustomModelBytes(cm).then((bytes) => this._provider.createSession(bytes, { imgsz }));
+	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);
 		}
-		return this._customSessionPromise;
-	}
-	async loadCustomModelBytes(cm) {
-		if (cm.path) return new Uint8Array(await readFile(cm.path));
-		if (cm.url) return this._store.fetchDirect(cm.url);
-		throw new Error("CustomModelConfig must specify either path or url");
+		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) {
-			const modelImgsz = YOLO_MODELS[key].imgsz ?? this.imgsz;
-			promise = this._store.ensure(key).then((bytes) => this._provider.createSession(bytes, { imgsz: modelImgsz })).catch((err) => {
+			promise = this._store.ensure(key).then((bytes) => this._provider.createSession(bytes)).catch((err) => {
 				this._sessions.delete(key);
 				this._store.evict(key);
 				throw err;
@@ -4298,59 +3917,103 @@ var YoloVisionRunner = class YoloVisionRunner$1 {
 		}
 		return promise;
 	}
-	prepareInput(image, key) {
-		const imgsz = YOLO_MODELS[key].imgsz ?? this.imgsz;
-		let scratch = this._tensorScratch.get(key);
-		if (!scratch || scratch.length < 3 * imgsz * imgsz) {
-			scratch = new Float32Array(3 * imgsz * imgsz);
-			this._tensorScratch.set(key, scratch);
+};
+function output(outputs, name, key) {
+	const tensor = outputs[name];
+	if (!tensor) throw new Error(`Vision model '${key}' returned no '${name}' output (got: ${Object.keys(outputs).join(", ") || "none"}). Expected the ${VISION_MODELS[key].source}.`);
+	return tensor;
+}
+/**
+* The frame's primary instance: the largest person when present, else the most confident
+* instance (lowest `detectionIndex` — detections are score-sorted). Size alone is a poor
+* signal without a person: the largest instance is usually a backdrop ("dining table").
+*/
+function selectSubjectMask(masks) {
+	let best;
+	for (const m of masks) {
+		if (!best) {
+			best = m;
+			continue;
 		}
-		return letterboxToTensor(normalizeImage(image), imgsz, scratch);
+		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;
 	}
-	decodeOptions(image, params, task = "detect") {
-		return {
-			confidence: this.confidence,
-			iouThreshold: this.iouThreshold,
-			classes: this.classes,
-			classNames: task === "obb" ? YOLO_DOTA_CLASSES : YOLO_COCO_CLASSES,
-			params,
-			sourceWidth: image.width,
-			sourceHeight: image.height,
-			maskThreshold: this.maskThreshold,
-			featherRadius: this.featherRadius
-		};
+	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;
+		}
 	}
-};
-function normalizeImage(image) {
-	if (image.data instanceof Uint8ClampedArray) return image;
-	return image;
+	return x1 < 0 ? null : {
+		x0,
+		y0,
+		x1,
+		y1
+	};
 }
-function pickByDims(outputs, rank) {
-	const hit = Object.values(outputs).find((t) => t.dims.length === rank);
-	if (!hit) throw new Error(`YOLO model returned no ${rank}D output — got [${Object.values(outputs).map((t) => t.dims.join("x")).join(", ")}]. Check the exported model task head.`);
-	return hit;
+/**
+* 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 hashPromptString(str) {
-	let h = 2166136261;
-	for (let i = 0; i < str.length; i++) h = Math.imul(h ^ str.charCodeAt(i), 16777619) >>> 0;
-	return h;
+function boundsArea(b) {
+	return (b.x1 - b.x0 + 1) * (b.y1 - b.y0 + 1);
 }
-function encodePromptEmbedding(prompt) {
-	let seed = hashPromptString(prompt);
-	const vec = new Float32Array(512);
-	let norm = 0;
-	for (let i = 0; i < 512; i++) {
-		seed = seed + 1831565813 >>> 0;
-		let t = seed;
-		t = Math.imul(t ^ t >>> 15, t | 1);
-		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-		const val = ((t ^ t >>> 14) >>> 0) / 4294967296 - .5;
-		vec[i] = val;
-		norm += val * val;
-	}
-	const invNorm = 1 / (Math.sqrt(norm) || 1);
-	for (let i = 0; i < 512; i++) vec[i] *= invNorm;
-	return vec;
+function boundsOverlap(a, b) {
+	const iw = Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0) + 1;
+	const ih = Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0) + 1;
+	if (iw <= 0 || ih <= 0) return 0;
+	return iw * ih / Math.min(boundsArea(a), boundsArea(b));
 }
 var SpatialLandmarkTransformer = class {
 	width;
@@ -4446,7 +4109,7 @@ function matchPoseToTracks(people, trackedObjects, minIoU = .15) {
 		const pBox = getPersonBoundingBox(person);
 		const isNormalized = pBox.width <= 1.05 && pBox.height <= 1.05;
 		for (const trk of personTracks) {
-			const iou = computeIoU$1(pBox, isNormalized && trk.boundingBox.normalizedWidth > 0 ? {
+			const iou = computeIoU(pBox, isNormalized && trk.boundingBox.normalizedWidth > 0 ? {
 				originX: trk.boundingBox.normalizedX,
 				originY: trk.boundingBox.normalizedY,
 				width: trk.boundingBox.normalizedWidth,
@@ -4479,13 +4142,12 @@ function matchPoseToTracks(people, trackedObjects, minIoU = .15) {
 		} : person;
 	});
 }
-var YoloVisionBundle = class {
+var VisionBundle = class {
 	objects;
 	poseLandmarks;
 	masks;
 	segmentation;
 	classes;
-	classification;
 	poseLandmarksTensor;
 	objectsTensor;
 	masksTensor;
@@ -4500,8 +4162,7 @@ var YoloVisionBundle = class {
 	_poseCache = /* @__PURE__ */ new Map();
 	_objectCache = /* @__PURE__ */ new Map();
 	_maskCache = /* @__PURE__ */ new Map();
-	_classifyCache = /* @__PURE__ */ new Map();
-	_obbCache = /* @__PURE__ */ new Map();
+	_matteCache = /* @__PURE__ */ new Map();
 	_poseLmCache = /* @__PURE__ */ new Map();
 	_trackCache = /* @__PURE__ */ new Map();
 	_categoryCache = /* @__PURE__ */ new Map();
@@ -4559,30 +4220,30 @@ var YoloVisionBundle = class {
 		const getOrCreatePoseLm = (index) => {
 			let sig = this._poseLmCache.get(index);
 			if (!sig) {
-				sig = createPoseCoord(index, POSE_KEYPOINT_NAMES[index] ?? `kpt_${index}`);
+				sig = createPoseCoord(index, COCO17_KEYPOINT_NAMES[index] ?? `kpt_${index}`);
 				this._poseLmCache.set(index, sig);
 			}
 			return sig;
 		};
 		const poseNamed = {
-			nose: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.NOSE),
-			leftEye: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_EYE),
-			rightEye: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_EYE),
-			leftEar: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_EAR),
-			rightEar: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_EAR),
-			shoulder: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_SHOULDER),
-			leftShoulder: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_SHOULDER),
-			rightShoulder: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_SHOULDER),
-			leftElbow: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_ELBOW),
-			rightElbow: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_ELBOW),
-			leftWrist: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_WRIST),
-			rightWrist: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_WRIST),
-			leftHip: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_HIP),
-			rightHip: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_HIP),
-			leftKnee: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_KNEE),
-			rightKnee: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_KNEE),
-			leftAnkle: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.LEFT_ANKLE),
-			rightAnkle: getOrCreatePoseLm(POSE_LANDMARKS_YOLO.RIGHT_ANKLE),
+			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) {
@@ -4658,7 +4319,7 @@ var YoloVisionBundle = class {
 				let bestIoU = .1;
 				for (const p of poseRes.people) {
 					const pBox = getPersonBoundingBox(p);
-					const iou = computeIoU$1(pBox, pBox.width <= 1.05 && pBox.height <= 1.05 && trk.boundingBox.normalizedWidth > 0 ? {
+					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,
@@ -4717,7 +4378,7 @@ var YoloVisionBundle = class {
 			const getOrCreateCoord = (idx) => {
 				let c = coordsCache.get(idx);
 				if (!c) {
-					c = createCoord(idx, POSE_KEYPOINT_NAMES[idx] ?? `kpt_${idx}`);
+					c = createCoord(idx, COCO17_KEYPOINT_NAMES[idx] ?? `kpt_${idx}`);
 					coordsCache.set(idx, c);
 				}
 				return c;
@@ -4731,16 +4392,16 @@ var YoloVisionBundle = class {
 					const prev = resolvePerson(Math.max(0, f - 1));
 					const currKp = curr.keypoints;
 					const prevKp = prev?.keypoints;
-					const rwCurr = currKp[POSE_LANDMARKS_YOLO.RIGHT_WRIST];
-					const rwPrev = prevKp?.[POSE_LANDMARKS_YOLO.RIGHT_WRIST];
+					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[POSE_LANDMARKS_YOLO.LEFT_WRIST];
-					const lwPrev = prevKp?.[POSE_LANDMARKS_YOLO.LEFT_WRIST];
+					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;
@@ -4756,10 +4417,10 @@ var YoloVisionBundle = class {
 					const p = resolvePerson(ctx.frame);
 					if (!p) return 0;
 					const k = p.keypoints;
-					const lw = k[POSE_LANDMARKS_YOLO.LEFT_WRIST];
-					const ls = k[POSE_LANDMARKS_YOLO.LEFT_SHOULDER];
-					const rw = k[POSE_LANDMARKS_YOLO.RIGHT_WRIST];
-					const rs = k[POSE_LANDMARKS_YOLO.RIGHT_SHOULDER];
+					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;
@@ -4771,10 +4432,10 @@ var YoloVisionBundle = class {
 					const p = resolvePerson(ctx.frame);
 					if (!p) return 0;
 					const k = p.keypoints;
-					const ls = k[POSE_LANDMARKS_YOLO.LEFT_SHOULDER];
-					const rs = k[POSE_LANDMARKS_YOLO.RIGHT_SHOULDER];
-					const lh = k[POSE_LANDMARKS_YOLO.LEFT_HIP];
-					const rh = k[POSE_LANDMARKS_YOLO.RIGHT_HIP];
+					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;
@@ -4788,24 +4449,24 @@ var YoloVisionBundle = class {
 					fps: this._fps,
 					label: `${label}_bodyTiltAngle`
 				}),
-				nose: getOrCreateCoord(POSE_LANDMARKS_YOLO.NOSE),
-				leftEye: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_EYE),
-				rightEye: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_EYE),
-				leftEar: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_EAR),
-				rightEar: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_EAR),
-				shoulder: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_SHOULDER),
-				leftShoulder: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_SHOULDER),
-				rightShoulder: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_SHOULDER),
-				leftElbow: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_ELBOW),
-				rightElbow: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_ELBOW),
-				leftWrist: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_WRIST),
-				rightWrist: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_WRIST),
-				leftHip: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_HIP),
-				rightHip: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_HIP),
-				leftKnee: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_KNEE),
-				rightKnee: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_KNEE),
-				leftAnkle: getOrCreateCoord(POSE_LANDMARKS_YOLO.LEFT_ANKLE),
-				rightAnkle: getOrCreateCoord(POSE_LANDMARKS_YOLO.RIGHT_ANKLE),
+				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) {
@@ -4879,26 +4540,6 @@ var YoloVisionBundle = class {
 					}, {
 						fps: this._fps,
 						label: `${label}_area`
-					}),
-					angle: programmaticSignal$1((ctx) => {
-						const b = getBox(ctx.frame);
-						const tcx = b.originX + b.width / 2;
-						const tcy = b.originY + b.height / 2;
-						let bestAngle = 0;
-						let bestDist = Infinity;
-						for (const d of self.getObbResult(ctx.frame).detections) {
-							const cx = d.boundingBox.originX + d.boundingBox.width / 2;
-							const cy = d.boundingBox.originY + d.boundingBox.height / 2;
-							const dist = (cx - tcx) * (cx - tcx) + (cy - tcy) * (cy - tcy);
-							if (dist < bestDist) {
-								bestDist = dist;
-								bestAngle = d.boundingBox.angle;
-							}
-						}
-						return bestAngle;
-					}, {
-						fps: this._fps,
-						label: `${label}_angle`
 					})
 				},
 				anchors: {
@@ -5057,21 +4698,7 @@ var YoloVisionBundle = class {
 			}
 		};
 		const maskForTrack = (frame, trackId) => this.getMaskResult(frame).find((m) => m.trackId === trackId);
-		const largestMask = (frame) => {
-			const masks = this.getMaskResult(frame);
-			if (masks.length === 0) return void 0;
-			let best = masks[0];
-			for (const m of masks) {
-				const bestIsPerson = best.category.toLowerCase() === "person";
-				const mIsPerson = m.category.toLowerCase() === "person";
-				if (mIsPerson && !bestIsPerson) {
-					best = m;
-					continue;
-				}
-				if (mIsPerson === bestIsPerson && m.area > best.area) best = m;
-			}
-			return best;
-		};
+		const subjectMask = (frame) => selectSubjectMask(this.getMaskResult(frame));
 		const buildMaskTrackSignals = (resolve$1, label) => {
 			const boxFor = (frame) => {
 				const mask = resolve$1(frame);
@@ -5124,7 +4751,7 @@ var YoloVisionBundle = class {
 				}
 				return sig;
 			},
-			subject: buildMaskTrackSignals(largestMask, "subject"),
+			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"
@@ -5134,24 +4761,17 @@ var YoloVisionBundle = class {
 			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.classification = {
-			top1: programmaticSignal$1((ctx) => self.getClassifyResult(ctx.frame).top1, {
-				fps: this._fps,
-				label: "classify_top1"
-			}),
-			top1Confidence: programmaticSignal$1((ctx) => self.getClassifyResult(ctx.frame).top1Score, {
-				fps: this._fps,
-				label: "classify_top1_conf"
-			}),
-			get top5() {
-				return self.getClassifyResult(frameSignal.value).top5;
-			},
-			top5At: (frame) => self.getClassifyResult(frame).top5
-		};
 		this.poseLandmarksTensor = {
 			get: (ctx) => self.getPoseLandmarksTensor(ctx?.frame ?? frameSignal.value),
 			get value() {
@@ -5229,27 +4849,16 @@ var YoloVisionBundle = class {
 	getMaskResult(frame) {
 		return this.latestAtOrBefore(this._maskCache, frame) ?? [];
 	}
-	setClassifyResult(frame, result) {
-		this._classifyCache.set(this.clamp(frame), result);
+	setMatteResult(frame, matte) {
+		this._matteCache.set(this.clamp(frame), matte);
 		this.invalidateSignals();
 	}
-	getClassifyResult(frame) {
-		return this.latestAtOrBefore(this._classifyCache, frame) ?? {
-			top1: 0,
-			top1Score: 0,
-			top5: []
-		};
-	}
-	setObbResult(frame, result) {
-		this._obbCache.set(this.clamp(frame), result);
-		this.invalidateSignals();
-	}
-	getObbResult(frame) {
-		return this.latestAtOrBefore(this._obbCache, frame) ?? { detections: [] };
+	getMatteResult(frame) {
+		return this.latestAtOrBefore(this._matteCache, frame);
 	}
 	/**
-	* Serializable snapshot of one frame's object / class / mask signals (specs/yolov4plan.ts
-	* §Phase A). Synchronous — reads only the per-frame caches, never triggers inference.
+	* 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);
@@ -5335,7 +4944,7 @@ var YoloVisionBundle = class {
 	getClassHistogramTensor(frame, nc = 80) {
 		const data = new Float32Array(nc);
 		for (const o of this.getObjectResult(frame).objects) if (o.active) {
-			const idx = YOLO_CLASS_INDEX_BY_NAME.get(o.category.toLowerCase());
+			const idx = COCO_CLASS_INDEX_BY_NAME.get(o.category.toLowerCase());
 			if (idx !== void 0) data[idx] += 1;
 		}
 		return {
@@ -5348,107 +4957,7 @@ var YoloVisionBundle = class {
 		return Math.max(0, Math.min(this._totalFrames - 1, Math.round(frame)));
 	}
 };
-const POSE_KEYPOINT_NAMES = [
-	"nose",
-	"leftEye",
-	"rightEye",
-	"leftEar",
-	"rightEar",
-	"leftShoulder",
-	"rightShoulder",
-	"leftElbow",
-	"rightElbow",
-	"leftWrist",
-	"rightWrist",
-	"leftHip",
-	"rightHip",
-	"leftKnee",
-	"rightKnee",
-	"leftAnkle",
-	"rightAnkle"
-];
-const YOLO_CLASS_INDEX_BY_NAME = new Map([
-	"person",
-	"bicycle",
-	"car",
-	"motorcycle",
-	"airplane",
-	"bus",
-	"train",
-	"truck",
-	"boat",
-	"traffic light",
-	"fire hydrant",
-	"stop sign",
-	"parking meter",
-	"bench",
-	"bird",
-	"cat",
-	"dog",
-	"horse",
-	"sheep",
-	"cow",
-	"elephant",
-	"bear",
-	"zebra",
-	"giraffe",
-	"backpack",
-	"umbrella",
-	"handbag",
-	"tie",
-	"suitcase",
-	"frisbee",
-	"skis",
-	"snowboard",
-	"sports ball",
-	"kite",
-	"baseball bat",
-	"baseball glove",
-	"skateboard",
-	"surfboard",
-	"tennis racket",
-	"bottle",
-	"wine glass",
-	"cup",
-	"fork",
-	"knife",
-	"spoon",
-	"bowl",
-	"banana",
-	"apple",
-	"sandwich",
-	"orange",
-	"broccoli",
-	"carrot",
-	"hot dog",
-	"pizza",
-	"donut",
-	"cake",
-	"chair",
-	"couch",
-	"potted plant",
-	"bed",
-	"dining table",
-	"toilet",
-	"tv",
-	"laptop",
-	"mouse",
-	"remote",
-	"keyboard",
-	"cell phone",
-	"microwave",
-	"oven",
-	"toaster",
-	"sink",
-	"refrigerator",
-	"book",
-	"clock",
-	"vase",
-	"scissors",
-	"teddy bear",
-	"hair drier",
-	"toothbrush"
-].map((name, index) => [name, index]));
+const COCO_CLASS_INDEX_BY_NAME = new Map(COCO_CLASSES.map((name, index) => [name, index]));
 function pinNodeToLandmark(node, target, options = {}) {
 	const offX = options.offsetX ?? 0;
 	const offY = options.offsetY ?? 0;
@@ -5493,46 +5002,50 @@ function pinNodeToObject(node, target, options = {}) {
 	}
 	return pinNodeToLandmark(node, target, options);
 }
+/** Tasks a config turns on; detection is the default when nothing is enabled explicitly. */
+function enabledTasks(config) {
+	const tasks = [];
+	if (config.enableDetection === true) tasks.push("detect");
+	if (config.enableSegmentation === true) tasks.push("segment");
+	if (config.enablePose === true) tasks.push("pose");
+	if (config.enableMatte === true) tasks.push("matte");
+	return tasks.length > 0 ? tasks : ["detect"];
+}
 /**
-* YOLO vision node.
+* Vision node.
 *
-* LAZY BY CONSTRUCTION: creating a YoloNode 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.
+* 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 YoloNode$1 = class YoloNode$1$1 {
+var VisionNode = class VisionNode$1 {
 	id;
-	kind = "yolo";
+	kind = "vision";
 	source;
 	config;
 	vision;
 	_runner;
-	/** Runner construction options (modelsDir, provider, …) — injectable for tests/agents. */
+	/** Runner construction options (modelsDir, provider, store, …) — injectable for tests/agents. */
 	_runnerOptions;
 	constructor(source, config = {}, bundleOptions = {}, runnerOptions = {}) {
-		this.id = "yolo-" + Math.random().toString(36).slice(2, 9);
+		this.id = `vision-${Math.random().toString(36).slice(2, 9)}`;
 		this.source = source;
 		this.config = config;
 		this._runnerOptions = runnerOptions;
-		this.vision = new YoloVisionBundle({
+		this.vision = new VisionBundle({
 			...bundleOptions,
 			config
 		});
 	}
-	/** Lazily-created runner; downloads happen here on first access. */
+	/** Lazily-created runner; downloads happen on its first inference. */
 	runner() {
 		if (!this._runner) {
-			const { variant, imgsz, confidence, iouThreshold, classes, enableWorld, prompts, customModel, modelsDir, baseUrl, maskThreshold, featherRadius } = this.config;
-			this._runner = YoloVisionRunner.create({
+			const { variant, confidence, classes, modelsDir, baseUrl, maskThreshold, featherRadius } = this.config;
+			this._runner = VisionRunner.create({
 				...this._runnerOptions,
 				...variant !== void 0 ? { variant } : {},
-				...imgsz !== void 0 ? { imgsz } : {},
 				...confidence !== void 0 ? { confidence } : {},
-				...iouThreshold !== void 0 ? { iouThreshold } : {},
 				...classes !== void 0 ? { classes } : {},
-				...enableWorld !== void 0 ? { enableWorld } : {},
-				...prompts !== void 0 ? { prompts } : {},
-				...customModel !== void 0 ? { customModel } : {},
 				...modelsDir !== void 0 ? { modelsDir } : {},
 				...baseUrl !== void 0 ? { baseUrl } : {},
 				...maskThreshold !== void 0 ? { maskThreshold } : {},
@@ -5544,15 +5057,7 @@ var YoloNode$1 = class YoloNode$1$1 {
 	/** Explicit warm-up — downloads the models for the enabled tasks, ahead of first inference. */
 	async ready() {
 		const runner = this.runner();
-		const tasks = [];
-		if (this.config.enableDetection === true) tasks.push("detect");
-		if (this.config.enableSegmentation === true) tasks.push("segment");
-		if (this.config.enablePose === true) tasks.push("pose");
-		if (this.config.enableObb === true) tasks.push("obb");
-		if (this.config.enableClassification === true) tasks.push("classify");
-		if (this.config.enableWorld === true) tasks.push("world");
-		const defaultTask = this.config.enableWorld === true ? "world" : "detect";
-		await runner.preload(tasks.length > 0 ? tasks : [defaultTask]);
+		await runner.preload(enabledTasks(this.config));
 		return runner;
 	}
 	close() {
@@ -5560,36 +5065,23 @@ var YoloNode$1 = class YoloNode$1$1 {
 		this._runner = void 0;
 	}
 	static attach(source, config = {}, bundleOptions = {}) {
-		const nodeInstance = new YoloNode$1$1(source, config, bundleOptions);
-		const vision = nodeInstance.vision;
-		Object.defineProperty(vision, "node", {
-			value: {
-				id: nodeInstance.id,
-				kind: "yolo",
-				source: nodeInstance.source,
-				config: nodeInstance.config
+		const node = new VisionNode$1(source, config, bundleOptions);
+		const vision = node.vision;
+		Object.defineProperties(vision, {
+			node: {
+				value: node.toNode(),
+				enumerable: true
 			},
-			enumerable: true,
-			writable: false
-		});
-		Object.defineProperty(vision, "ready", {
-			value: () => nodeInstance.ready(),
-			enumerable: false
-		});
-		Object.defineProperty(vision, "runner", {
-			value: () => nodeInstance.runner(),
-			enumerable: false
-		});
-		Object.defineProperty(vision, "close", {
-			value: () => nodeInstance.close(),
-			enumerable: false
+			ready: { value: () => node.ready() },
+			runner: { value: () => node.runner() },
+			close: { value: () => node.close() }
 		});
 		return vision;
 	}
 	toNode() {
 		return {
 			id: this.id,
-			kind: "yolo",
+			kind: "vision",
 			source: this.source,
 			config: this.config
 		};
@@ -19639,11 +19131,12 @@ const VignetteWebGPURenderer = async (args) => {
 var renderers_default$1 = defineRenderer({ WebGPURenderer: VignetteWebGPURenderer });
 
 //#endregion
-//#region ../../nodes/node-yolo/dist/renderers-mupYaxMa.mjs
+//#region ../../nodes/node-vision/dist/renderers-CpOzS0Wl.mjs
 let sharedRunner = null;
 let sharedSkeletonRenderer = null;
 let sharedTexturePool = null;
-let sharedObjectTracker = null;
+/** One tracker per vision node — track ids must not mix across nodes/sources. */
+const objectTrackers = /* @__PURE__ */ new Map();
 /**
 * Persistent per-node child textures. The shared frame encoder is submitted at
 * the END of the frame, so a node renderer cannot read back the child it just
@@ -19651,46 +19144,50 @@ let sharedObjectTracker = null;
 * the start of the next call — a stable one-frame delay instead of the
 * unpredictable multi-frame lag you get from pooled textures.
 *
-* Keyed on the stable Yolo `Effect` instance (render ids change every frame),
+* Keyed on the stable Vision `Effect` instance (render ids change every frame),
 * with a size-keyed fallback for raw operation nodes.
 */
-const yoloChildTexturesByEffect = /* @__PURE__ */ new WeakMap();
-const yoloChildTexturesByKey = /* @__PURE__ */ new Map();
+const childTexturesByEffect = /* @__PURE__ */ new WeakMap();
+const childTexturesByKey = /* @__PURE__ */ new Map();
 /**
 * Last successful subject mask, reused for a few frames when the model misses —
 * a transient miss then holds the silhouette instead of flashing the raw plate.
-* Keyed per node/effect so multiple YOLO nodes do not collide.
+* Keyed per node/effect so multiple vision nodes do not collide.
 */
 const lastSubjectByNode = /* @__PURE__ */ new Map();
 const SUBJECT_HOLD_FRAMES = 3;
 /**
 * Lazy shared runner — `create()` is a pure constructor (zero I/O); the first frame that
 * requests a task triggers that task's model download at inference time (never at init).
+* Recreated only when an option that changes inference changes.
 */
 function getSharedRunner(op) {
-	if (!sharedRunner || sharedRunner.variant !== op.variant || sharedRunner.enableWorld !== op.enableWorld || sharedRunner.prompts !== op.prompts || sharedRunner.customModel !== op.customModel || sharedRunner.featherRadius !== op.featherRadius || sharedRunner.maskThreshold !== op.maskThreshold) sharedRunner = YoloVisionRunner.create({
+	const options = {
 		variant: op.variant,
-		imgsz: op.imgsz,
 		confidence: op.confidence,
-		iouThreshold: op.iouThreshold,
 		classes: op.classes,
-		enableWorld: op.enableWorld,
-		prompts: op.prompts,
-		customModel: op.customModel,
 		maskThreshold: op.maskThreshold,
 		featherRadius: op.featherRadius,
 		modelsDir: op.modelsDir,
 		baseUrl: op.baseUrl
-	});
-	return sharedRunner;
+	};
+	const key = JSON.stringify(options);
+	if (sharedRunner?.key !== key) {
+		sharedRunner?.runner.close();
+		sharedRunner = {
+			key,
+			runner: VisionRunner.create(options)
+		};
+	}
+	return sharedRunner.runner;
 }
-/** Lazy shared tracker — detections (incl. OBB) are tracked under one stable identity space. */
-function getSharedObjectTracker(op) {
-	if (!sharedObjectTracker) sharedObjectTracker = new TemporalObjectTracker({
-		iouThreshold: op.iouThreshold ?? .25,
-		maxMissedFrames: op.maxMissedFrames ?? 15
-	});
-	return sharedObjectTracker;
+function getObjectTracker(nodeKey, op) {
+	let tracker = objectTrackers.get(nodeKey);
+	if (!tracker) {
+		tracker = new TemporalObjectTracker({ maxMissedFrames: op.maxMissedFrames ?? 15 });
+		objectTrackers.set(nodeKey, tracker);
+	}
+	return tracker;
 }
 /**
 * Normalizes the runner's pose keypoints (plate pixel space) to [0, 1] landmarks, which is
@@ -19727,26 +19224,11 @@ function assignMasksToTracks(masks, tracked) {
 		} : mask;
 	});
 }
-/** Picks the subject mask: the largest instance, preferring a person when present. */
-function selectSubjectMask(masks) {
-	if (masks.length === 0) return void 0;
-	let best = masks[0];
-	for (const m of masks) {
-		const mIsPerson = m.category.toLowerCase() === "person";
-		const bestIsPerson = best.category.toLowerCase() === "person";
-		if (mIsPerson && !bestIsPerson) {
-			best = m;
-			continue;
-		}
-		if (mIsPerson === bestIsPerson && m.area > best.area) best = m;
-	}
-	return best;
-}
 /**
-* Grows a person mask into connected foreground pixels — the COCO person head
-* drops a flowing dress (treats it as non-person), so seeding a flood fill from
-* the body through pixels that differ from the sampled backdrop recovers the
-* fabric without adding the near-uniform studio wall or its soft grey shadow.
+* Grows a subject mask into connected foreground pixels — seeding a flood fill
+* from the subject through pixels that differ from the sampled backdrop recovers
+* thin or fast-moving edges (hair, fabric) without adding a near-uniform studio
+* wall or its soft grey shadow.
 */
 function fillInternalHoles(mask, width, height) {
 	const exterior = new Uint8Array(width * height);
@@ -19889,26 +19371,25 @@ function maskCentroid(mask) {
 		cy: sumY / count
 	};
 }
-const YoloWebGPURenderer = async (args) => {
+const VisionWebGPURenderer = async (args) => {
 	const { ctx, encoder, pass, targetView, targetWidth, targetHeight, props, drawChild } = args;
 	const { virtualMedia } = props;
 	const rawOp = virtualMedia?.operation;
-	if (!rawOp) return;
-	const op = normalizeOperation(rawOp);
-	if (!op) return;
+	if (rawOp?.op !== "Vision") return;
+	const op = rawOp;
 	pass.end();
 	const childMedia = virtualMedia?.children?.[0];
 	if (!childMedia) return;
 	const effectKey = op.effect;
 	const hasEffectKey = effectKey !== void 0 && effectKey !== null;
 	const nodeKeyStr = virtualMedia?.id ?? rawOp?.id ?? `${targetWidth}x${targetHeight}_${op.mode}_${op.variant}_${op.keyBackground}_${op.backgroundKeyThreshold}`;
-	const fallbackKey = `yolo-${nodeKeyStr}`;
-	let childTex = hasEffectKey ? yoloChildTexturesByEffect.get(effectKey) : yoloChildTexturesByKey.get(fallbackKey);
+	const fallbackKey = `vision-${nodeKeyStr}`;
+	let childTex = hasEffectKey ? childTexturesByEffect.get(effectKey) : childTexturesByKey.get(fallbackKey);
 	if (childTex && (childTex.width !== targetWidth || childTex.height !== targetHeight)) {
 		childTex.destroy();
 		childTex = void 0;
-		if (hasEffectKey) yoloChildTexturesByEffect.delete(effectKey);
-		else yoloChildTexturesByKey.delete(fallbackKey);
+		if (hasEffectKey) childTexturesByEffect.delete(effectKey);
+		else childTexturesByKey.delete(fallbackKey);
 	}
 	const hasPreviousFrame = childTex !== void 0;
 	if (!childTex) {
@@ -19916,15 +19397,15 @@ const YoloWebGPURenderer = async (args) => {
 			size: [targetWidth, targetHeight],
 			format: ctx.renderer.format,
 			usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
-			label: "yolo_child_persistent"
+			label: "vision_child_persistent"
 		});
-		if (hasEffectKey) yoloChildTexturesByEffect.set(effectKey, childTex);
-		else yoloChildTexturesByKey.set(fallbackKey, childTex);
-		if (yoloChildTexturesByKey.size > 4) {
-			const oldest = yoloChildTexturesByKey.keys().next().value;
+		if (hasEffectKey) childTexturesByEffect.set(effectKey, childTex);
+		else childTexturesByKey.set(fallbackKey, childTex);
+		if (childTexturesByKey.size > 4) {
+			const oldest = childTexturesByKey.keys().next().value;
 			if (oldest && oldest !== fallbackKey) {
-				yoloChildTexturesByKey.get(oldest)?.destroy();
-				yoloChildTexturesByKey.delete(oldest);
+				childTexturesByKey.get(oldest)?.destroy();
+				childTexturesByKey.delete(oldest);
 			}
 		}
 	}
@@ -19936,9 +19417,9 @@ const YoloWebGPURenderer = async (args) => {
 		const stagingBuffer = ctx.device.createBuffer({
 			size: bufferSize,
 			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-			label: "yolo_frame_staging"
+			label: "vision_frame_staging"
 		});
-		const readbackEncoder = ctx.device.createCommandEncoder({ label: "yolo_readback_encoder" });
+		const readbackEncoder = ctx.device.createCommandEncoder({ label: "vision_readback_encoder" });
 		readbackEncoder.copyTextureToBuffer({ texture: childTex }, {
 			buffer: stagingBuffer,
 			bytesPerRow,
@@ -19966,62 +19447,45 @@ const YoloWebGPURenderer = async (args) => {
 	}, targetWidth, targetHeight, "clear").end();
 	await drawChild(childMedia, { ...props }, childView, childTex, targetWidth, targetHeight);
 	const frameIdx = props.frame ?? 0;
+	const fps = props.fps ?? 24;
+	const mode = op.mode ?? "passthrough";
+	const isMatteMode = mode === "mask" || mode === "matte" || mode === "crop";
 	const visionBundle = op.visionBundle ?? virtualMedia.visionBundle;
-	const runner = await getSharedRunner(op);
+	const runner = getSharedRunner(op);
 	const image = framePixels ? {
 		data: framePixels,
 		width: targetWidth,
 		height: targetHeight
 	} : null;
-	if (image && op.mode !== "obb" && (op.enableDetection !== false || op.mode === "boxes" || op.mode === "tracking")) {
+	let frameObjects = [];
+	if (image && (op.enableDetection !== false || mode === "boxes" || mode === "tracking")) {
 		const detections = await runner.detect(image);
-		const tracker = getSharedObjectTracker(op);
+		const tracker = getObjectTracker(nodeKeyStr, op);
 		if (frameIdx === 0) tracker.reset();
-		const tracked = tracker.update(detections, frameIdx, props.fps ?? 24);
+		frameObjects = tracker.update(detections, frameIdx, fps);
 		visionBundle?.setObjectResult(frameIdx, {
-			objects: tracked,
+			objects: frameObjects,
 			rawDetections: detections
 		});
 	}
-	const needsSegmentation = op.enableSegmentation === true || op.mode === "mask" || op.mode === "matte" || op.mode === "crop";
 	let frameMasks = [];
-	if (image && needsSegmentation) {
-		const segRes = await runner.segment(image);
-		const tracked = visionBundle?.getObjectResult(frameIdx).objects ?? [];
-		frameMasks = assignMasksToTracks(segRes.masks, tracked);
+	if (image && (op.enableSegmentation === true || isMatteMode && op.matteSource !== "selfie")) {
+		frameMasks = assignMasksToTracks((await runner.segment(image)).masks, frameObjects);
 		visionBundle?.setMaskResult(frameIdx, frameMasks);
 	}
+	let personMatte;
+	if (image && (op.enableMatte === true || isMatteMode && op.matteSource === "selfie")) {
+		personMatte = await runner.matte(image);
+		visionBundle?.setMatteResult(frameIdx, personMatte);
+	}
 	let currentPoseRes;
-	if (image && (op.enablePose === true || op.mode === "skeleton")) {
-		const normalized = normalizePoseKeypoints(await runner.pose(image), image.width, image.height);
-		const tracked = visionBundle?.getObjectResult(frameIdx).objects ?? [];
-		currentPoseRes = { people: matchPoseToTracks(normalized.people, tracked) };
+	if (image && (op.enablePose === true || mode === "skeleton")) {
+		currentPoseRes = { people: matchPoseToTracks(normalizePoseKeypoints(await runner.pose(image), image.width, image.height).people, frameObjects) };
 		visionBundle?.setPoseResult(frameIdx, currentPoseRes);
 	}
-	if (image && op.enableClassification === true) {
-		const classifyRes = await runner.classify(image);
-		visionBundle?.setClassifyResult(frameIdx, classifyRes);
-	}
-	if (image && (op.enableObb === true || op.mode === "obb")) {
-		const obbRes = await runner.detectObb(image);
-		visionBundle?.setObbResult(frameIdx, obbRes);
-		const detections = obbRes.detections.map((d) => ({
-			category: d.category,
-			score: d.score,
-			boundingBox: d.boundingBox
-		}));
-		const tracker = getSharedObjectTracker(op);
-		if (frameIdx === 0) tracker.reset();
-		const tracked = tracker.update(detections, frameIdx, props.fps ?? 24);
-		visionBundle?.setObjectResult(frameIdx, {
-			objects: tracked,
-			rawDetections: detections
-		});
-	}
-	const mode = op.mode ?? "passthrough";
-	if (mode === "mask" || mode === "matte" || mode === "crop") {
+	if (isMatteMode) {
 		if (!sharedTexturePool) sharedTexturePool = new SegmentationTexturePool(ctx.device);
-		const selected = selectSubjectMask(frameMasks.length > 0 ? frameMasks : visionBundle?.getMaskResult(frameIdx) ?? []);
+		const selected = op.matteSource === "selfie" ? personMatteAsMask(personMatte) : mergeSubjectMask(frameMasks.length > 0 ? frameMasks : visionBundle?.getMaskResult(frameIdx) ?? []);
 		let subject;
 		const lastSubjectEntry = lastSubjectByNode.get(nodeKeyStr);
 		const lastSubjectMask = lastSubjectEntry?.mask ?? null;
@@ -20095,39 +19559,6 @@ const YoloWebGPURenderer = async (args) => {
 			return;
 		}
 	}
-	if (mode === "obb") {
-		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
-			r: 0,
-			g: 0,
-			b: 0,
-			a: 0
-		}, targetWidth, targetHeight, "clear");
-		ctx.renderer.drawTexture(outPass$1, childTex, {
-			x: 0,
-			y: 0,
-			width: targetWidth,
-			height: targetHeight
-		});
-		const detections = visionBundle?.getObbResult(frameIdx).detections ?? [];
-		const obbColor = "#f59e0b";
-		for (const det of detections) {
-			if (det.corners.length < 4) continue;
-			const path$1 = det.corners.map((corner, i) => `${i === 0 ? "M" : "L"} ${corner[0]} ${corner[1]}`).join(" ") + " Z";
-			try {
-				ctx.renderer.drawPath(outPass$1, path$1, obbColor, 2);
-			} catch {
-				const b = det.boundingBox;
-				ctx.renderer.drawRect(outPass$1, {
-					x: b.originX,
-					y: b.originY,
-					width: b.width,
-					height: b.height
-				}, obbColor, 2);
-			}
-		}
-		outPass$1.end();
-		return;
-	}
 	if (mode === "boxes" || mode === "tracking") {
 		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
 			r: 0,
@@ -20141,11 +19572,11 @@ const YoloWebGPURenderer = async (args) => {
 			width: targetWidth,
 			height: targetHeight
 		});
-		const objRes = visionBundle?.getObjectResult(frameIdx);
-		if (objRes && objRes.objects.length > 0) {
+		const objects = frameObjects.length > 0 ? frameObjects : visionBundle?.getObjectResult(frameIdx).objects ?? [];
+		if (objects.length > 0) {
 			const boxColor = "#38bdf8";
 			const stroke = 2;
-			for (const obj of objRes.objects) {
+			for (const obj of objects) {
 				if (!obj.active) continue;
 				const b = obj.boundingBox;
 				ctx.renderer.drawRect(outPass$1, {
@@ -20235,73 +19666,48 @@ function uploadComposite(pool, mode, subject, framePixels, width, height, frameI
 			out[px + 3] = alpha;
 		}
 	}
-	const key = `yolo_composite_${nodeKeyStr}_${mode}_${frameIdx}`;
+	const key = `vision_composite_${nodeKeyStr}_${mode}_${frameIdx}`;
 	const tex = pool.uploadMask(key, out, width, height);
 	if (mode === "crop") {
-		const box = subjectBoundingBox(subject);
-		if (box) {
-			const cropW = Math.max(1, Math.round(box.width));
-			const cropH = Math.max(1, Math.round(box.height));
-			const crop = new Uint8Array(width * height * 4);
-			for (let y = 0; y < height; y++) {
-				const srcY = Math.min(cropH - 1, Math.max(0, Math.round(y / height * cropH)));
-				for (let x = 0; x < width; x++) {
-					const srcX = Math.min(cropW - 1, Math.max(Math.round(x / width * cropW)));
-					const srcIdx = (srcY * width + srcX) * 4;
-					const dstIdx = (y * width + x) * 4;
-					crop[dstIdx] = out[srcIdx];
-					crop[dstIdx + 1] = out[srcIdx + 1];
-					crop[dstIdx + 2] = out[srcIdx + 2];
-					crop[dstIdx + 3] = out[srcIdx + 3];
-				}
-			}
-			return pool.uploadMask(`yolo_crop_${frameIdx}`, crop, width, height);
-		}
+		const box = maskBounds(subject);
+		if (box) return pool.uploadMask(`vision_crop_${nodeKeyStr}_${frameIdx}`, cropToBounds(out, width, height, box), width, height);
 	}
 	return tex;
 }
-function subjectBoundingBox(subject) {
-	const { mask, width } = subject;
-	let minX = width;
-	let minY = Infinity;
-	let maxX = -1;
-	let maxY = -1;
-	for (let y = 0; y < subject.height; y++) for (let x = 0; x < width; x++) if (mask[y * width + x] > 0) {
-		if (x < minX) minX = x;
-		if (x > maxX) maxX = x;
-		if (y < minY) minY = y;
-		if (y > maxY) maxY = y;
-	}
-	if (maxX < minX || maxY < minY) return null;
+/** Nearest-neighbour resample of `bounds` inside an RGBA frame up to the full frame. */
+function cropToBounds(rgba, width, height, bounds) {
+	const cropW = bounds.x1 - bounds.x0 + 1;
+	const cropH = bounds.y1 - bounds.y0 + 1;
+	const crop = new Uint8Array(width * height * 4);
+	for (let y = 0; y < height; y++) {
+		const srcY = bounds.y0 + Math.min(cropH - 1, Math.floor(y / height * cropH));
+		for (let x = 0; x < width; x++) {
+			const srcX = bounds.x0 + Math.min(cropW - 1, Math.floor(x / width * cropW));
+			const src = (srcY * width + srcX) * 4;
+			const dst = (y * width + x) * 4;
+			crop[dst] = rgba[src];
+			crop[dst + 1] = rgba[src + 1];
+			crop[dst + 2] = rgba[src + 2];
+			crop[dst + 3] = rgba[src + 3];
+		}
+	}
+	return crop;
+}
+/** Adapts a Selfie Segmenter matte to the instance-mask shape the composite path takes. */
+function personMatteAsMask(matte) {
+	if (!matte || matte.coverage <= 0) return void 0;
+	const area = Math.round(matte.coverage * matte.width * matte.height);
 	return {
-		width: maxX - minX + 1,
-		height: maxY - minY + 1
+		category: "person",
+		mask: matte.mask,
+		width: matte.width,
+		height: matte.height,
+		area,
+		coverage: matte.coverage,
+		detectionIndex: -1
 	};
 }
-/**
-* Legacy-compat: accepts a `MediaPipe` operation (from compositions targeting the old
-* node) and maps its flags onto the YOLO config — pose, object tracking, segmentation,
-* and passthrough/mask/skeleton/boxes/tracking modes all carry over.
-*/
-function normalizeOperation(raw) {
-	if (raw.op === "Yolo") return raw;
-	if (raw.op === "MediaPipe") {
-		const legacy = raw;
-		return {
-			...raw,
-			op: "Yolo",
-			enableDetection: legacy.enableObjectTracking === true || legacy.mode === "boxes" || legacy.mode === "tracking",
-			enablePose: legacy.enablePoseLandmarks === true || legacy.mode === "skeleton",
-			enableSegmentation: legacy.enableSegmentation === true || legacy.mode === "mask" || legacy.mode === "matte",
-			confidence: legacy.objectScoreThreshold ?? .25,
-			iouThreshold: legacy.iouThreshold ?? .45,
-			classes: legacy.objectCategories ?? void 0,
-			modelsDir: legacy.modelsDir ?? void 0
-		};
-	}
-	return null;
-}
-var renderers_default = defineRenderer({ WebGPURenderer: YoloWebGPURenderer });
+var renderers_default = defineRenderer({ WebGPURenderer: VisionWebGPURenderer });
 
 //#endregion
 //#region src/effects/with-defaults.ts
@@ -21036,42 +20442,26 @@ var Crop = class extends Effect {
 		});
 	}
 };
-var Yolo = class extends Effect {
-	op = "Yolo";
+/**
+* On-device vision: tracks objects, segments instances, estimates pose and mattes people on
+* the rendered frame, feeding reactive signals. Models download lazily on first use.
+*/
+var Vision = class extends Effect {
+	op = "Vision";
 	constructor(config = {}) {
 		super({
 			enableDetection: config.enableDetection !== false,
 			enableSegmentation: config.enableSegmentation === true,
 			enablePose: config.enablePose === true,
-			enableClassification: config.enableClassification === true,
-			enableObb: config.enableObb === true,
-			confidence: config.confidence ?? .25,
-			iouThreshold: config.iouThreshold ?? .45,
-			variant: config.variant ?? "n",
-			imgsz: config.imgsz ?? 640,
+			enableMatte: config.enableMatte === true,
+			confidence: config.confidence ?? .3,
+			variant: config.variant ?? "s",
 			mode: config.mode ?? "passthrough",
-			delegate: config.delegate ?? "CPU",
+			matteSource: config.matteSource ?? "instance",
 			...config
 		});
 	}
 };
-/**
-* @deprecated Use `Yolo`. Kept as a source-compatible alias that maps the legacy MediaPipe
-* option shape onto the YOLO engine (`op` is `"Yolo"`).
-*/
-var MediaPipe = class extends Yolo {
-	constructor(config = {}) {
-		super({
-			enableDetection: true,
-			enablePose: config.enablePoseLandmarks !== false,
-			enableSegmentation: config.enableSegmentation === true,
-			mode: config.mode === "skeleton" ? "skeleton" : config.mode ?? "passthrough",
-			...config.delegate !== void 0 ? { delegate: config.delegate } : {},
-			...config.modelsDir !== void 0 ? { modelsDir: config.modelsDir } : {},
-			...config.visionBundle !== void 0 ? { visionBundle: config.visionBundle } : {}
-		});
-	}
-};
 var Relight3D = class extends Effect {
 	op = "Relight3D";
 	constructor(config = {}) {
@@ -21126,5 +20516,5 @@ var Modulate = class extends Effect {
 };
 
 //#endregion
-export { renderers_default$23 as $, renderers_default as A, renderers_default$10 as B, Yolo as C, DepthNormalsComputePipeline as Ct, ColorKey as D, ColorBalance as E, TensorPipeline as Et, renderers_default$5 as F, renderers_default$15 as G, renderers_default$12 as H, renderers_default$6 as I, renderers_default$18 as J, renderers_default$16 as K, renderers_default$7 as L, renderers_default$2 as M, renderers_default$3 as N, Vignette as O, renderers_default$4 as P, renderers_default$22 as Q, renderers_default$8 as R, UnsharpMask as S, ControlNetMultiplexer as St, Blur as T, TemporalDeflickerPipeline as Tt, renderers_default$13 as U, renderers_default$11 as V, renderers_default$14 as W, renderers_default$20 as X, renderers_default$19 as Y, renderers_default$21 as Z, SSAO as _, YoloVisionRunner as _t, CustomEffect as a, renderers_default$29 as at, TemporalDeflicker as b, pinNodeToObject as bt, GradientMap as c, POSE_LANDMARKS_YOLO as ct, Levels as d, SpatialLandmarkTransformer as dt, renderers_default$24 as et, MediaPipe as f, TemporalObjectTracker as ft, Relight3D as g, YoloVisionBundle as gt, PBRGlass as h, YoloNode$1 as ht, Curves as i, renderers_default$28 as it, renderers_default$1 as j, effectMeta as k, HalftoneScreen as l, PoseSkeletonRenderer as lt, MotionBlur as m, YOLO_POSE_KEYPOINT_NAMES as mt, AudioSignalExtractor as n, renderers_default$26 as nt, DepthOfField as o, renderers_default$30 as ot, Modulate as p, YOLO_COCO17_BONES as pt, renderers_default$17 as q, Crop as r, renderers_default$27 as rt, FilmGrain as s, MEDIAPIPE_TO_YOLO_POSE_INDEX as st, ApplyLUT as t, renderers_default$25 as tt, HighPass as u, SegmentationTexturePool as ut, SelectiveColor as v, analyzeSequence as vt, effectFactories as w, OpticalFlowComputePipeline as wt, TileOffset as x, CannyComputePipeline as xt, ShadowsHighlights as y, pinNodeToLandmark as yt, renderers_default$9 as z };
-//# sourceMappingURL=effects-4t4qk-BR.mjs.map
+export { renderers_default$24 as $, renderers_default$1 as A, renderers_default$11 as B, effectFactories as C, OpticalFlowComputePipeline as Ct, Vignette as D, ColorKey as E, renderers_default$6 as F, renderers_default$16 as G, renderers_default$13 as H, renderers_default$7 as I, renderers_default$19 as J, renderers_default$17 as K, renderers_default$8 as L, renderers_default$3 as M, renderers_default$4 as N, effectMeta as O, renderers_default$5 as P, renderers_default$23 as Q, renderers_default$9 as R, Vision as S, DepthNormalsComputePipeline as St, ColorBalance as T, TensorPipeline as Tt, renderers_default$14 as U, renderers_default$12 as V, renderers_default$15 as W, renderers_default$21 as X, renderers_default$20 as Y, renderers_default$22 as Z, SelectiveColor as _, pinNodeToLandmark as _t, CustomEffect as a, renderers_default$30 as at, TileOffset as b, CannyComputePipeline as bt, GradientMap as c, COCO17_KEYPOINT_NAMES as ct, Levels as d, SpatialLandmarkTransformer as dt, renderers_default$25 as et, Modulate as f, TemporalObjectTracker as ft, SSAO as g, analyzeSequence as gt, Relight3D as h, VisionRunner as ht, Curves as i, renderers_default$29 as it, renderers_default$2 as j, renderers_default as k, HalftoneScreen as l, PoseSkeletonRenderer as lt, PBRGlass as m, VisionNode as mt, AudioSignalExtractor as n, renderers_default$27 as nt, DepthOfField as o, COCO17_BONES as ot, MotionBlur as p, VisionBundle as pt, renderers_default$18 as q, Crop as r, renderers_default$28 as rt, FilmGrain as s, COCO17_KEYPOINTS as st, ApplyLUT as t, renderers_default$26 as tt, HighPass as u, SegmentationTexturePool as ut, ShadowsHighlights as v, pinNodeToObject as vt, Blur as w, TemporalDeflickerPipeline as wt, UnsharpMask as x, ControlNetMultiplexer as xt, TemporalDeflicker as y, COCO_CLASSES as yt, renderers_default$10 as z };
+//# sourceMappingURL=effects-C9connag.mjs.map