framefields 2.2.0-beta.0 → 2.2.0-beta.2

package/dist/{renderer-mp1NN5zk.mjs → renderer-CqT2vxa4.mjs}

@@ -190,7 +190,7 @@ const COCO_CLASSES = [
 ];
 
 //#endregion
-//#region ../vision/dist/src-C2sA_wDT.mjs
+//#region ../vision/dist/src-CQS94ONs.mjs
 function computeIoU(boxA, boxB) {
 	const xA = Math.max(boxA.originX, boxB.originX);
 	const yA = Math.max(boxA.originY, boxB.originY);
@@ -263,11 +263,11 @@ var TemporalObjectTracker = class {
 			for (let d = 0; d < detections.length; d++) {
 				const det = detections[d];
 				if (trk.category !== det.category) continue;
-				const iou = computeIoU(trk.box, det.boundingBox);
-				if (iou >= this._iouThreshold) candidateMatches.push({
+				const iou$1 = computeIoU(trk.box, det.boundingBox);
+				if (iou$1 >= this._iouThreshold) candidateMatches.push({
 					trackIdx: t,
 					detIdx: d,
-					iou
+					iou: iou$1
 				});
 			}
 		}
@@ -858,11 +858,13 @@ function decodeRtmdetIns(out, opts) {
 	kept.sort((a, b) => b.detection.score - a.detection.score);
 	const detections = kept.map((k) => k.detection);
 	const masks = [];
-	if (!out.masks) return {
+	if (!out.masks && !out.maskPlane) return {
 		detections,
 		masks
 	};
-	const alphaOf = probabilityToAlpha(opts.maskThreshold ?? .5, opts.featherRadius ?? .05);
+	const threshold = opts.maskThreshold ?? .5;
+	const feather = opts.featherRadius ?? .05;
+	const alphaOf = out.maskLogits ? logitToAlpha(threshold, feather) : probabilityToAlpha(threshold, feather);
 	const { maskWidth: mw, maskHeight: mh } = out;
 	const plane = mw * mh;
 	const gx = mw / transform.inputWidth;
@@ -870,7 +872,8 @@ function decodeRtmdetIns(out, opts) {
 	for (let d = 0; d < kept.length; d++) {
 		const { index, detection } = kept[d];
 		const box = detection.boundingBox;
-		const base = index * plane;
+		const data = out.maskPlane ? out.maskPlane(index) : out.masks;
+		const base = out.maskPlane ? 0 : 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);
@@ -888,7 +891,7 @@ function decodeRtmdetIns(out, opts) {
 				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);
+				const alpha = alphaOf(data[base + my0 * mw + mx0] * (1 - fx) * (1 - fy) + data[base + my0 * mw + mx1] * fx * (1 - fy) + data[base + my1 * mw + mx0] * (1 - fx) * fy + data[base + my1 * mw + mx1] * fx * fy);
 				if (alpha > 0) {
 					mask[row + sx] = alpha;
 					area += alpha / 255;
@@ -922,6 +925,21 @@ function probabilityToAlpha(threshold, feather) {
 	const inv = 255 / (2 * feather);
 	return (p) => p <= lo ? 0 : p >= threshold + feather ? 255 : (p - lo) * inv;
 }
+/**
+* Logit → 0..255 alpha: `probabilityToAlpha` after a sigmoid, which is only
+* evaluated inside the feather band.
+*/
+function logitToAlpha(threshold, feather) {
+	const toAlpha = probabilityToAlpha(threshold, feather);
+	const logit = (p) => p <= 0 ? -Infinity : p >= 1 ? Infinity : Math.log(p / (1 - p));
+	if (feather <= 0) {
+		const edge = logit(threshold);
+		return (l) => l > edge ? 255 : 0;
+	}
+	const lo = logit(threshold - feather);
+	const hi = logit(threshold + feather);
+	return (l) => l <= lo ? 0 : l >= hi ? 255 : toAlpha(1 / (1 + Math.exp(-l)));
+}
 function clamp$1(v, lo, hi) {
 	return v < lo ? lo : v > hi ? hi : v;
 }
@@ -972,9 +990,9 @@ function decodeRtmo(out, opts) {
 		});
 	}
 	people.sort((a, b) => b.score - a.score);
-	const iou = opts.iouThreshold ?? .6;
+	const iou$1 = opts.iouThreshold ?? .6;
 	const kept = [];
-	for (const p of people) if (!kept.some((k) => isDuplicate(k, p, iou))) kept.push(p);
+	for (const p of people) if (!kept.some((k) => isDuplicate(k, p, iou$1))) kept.push(p);
 	return { people: kept };
 }
 function clamp(v, lo, hi) {
@@ -985,8 +1003,8 @@ function clamp(v, lo, hi) {
 * within 10% of the stronger detection's box size of each other (boxes may differ when one
 * of them also covers a flowing garment or a shadow).
 */
-function isDuplicate(a, b, iou) {
-	if (computeIoU(a.boundingBox, b.boundingBox) > iou) return true;
+function isDuplicate(a, b, iou$1) {
+	if (computeIoU(a.boundingBox, b.boundingBox) > iou$1) return true;
 	const scale = Math.sqrt(a.boundingBox.width * a.boundingBox.height);
 	let sum = 0;
 	let n = 0;
@@ -1028,6 +1046,286 @@ function decodeSelfie(alphas, matteWidth, matteHeight, opts) {
 		coverage: sw * sh > 0 ? sum / (255 * sw * sh) : 0
 	};
 }
+/**
+* Frame preprocessing on the GPU: a texture becomes a model's NCHW float input
+* in a storage buffer, so a frame drawn by the renderer reaches the model
+* without a round trip through the CPU. The math is `imageToTensor`'s
+* (pixel-centre bilinear sampling, letterbox padding, channel order,
+* normalisation); see decode/preprocess.ts for the per-model contracts.
+*
+* Also: a content hash of a texture (two order-independent 32-bit sums, read
+* back as 8 bytes), so layers showing the same pixels can share a pass, and a
+* plain RGBA readback for paths that need pixels on the CPU.
+*/
+const TENSOR_WGSL = `
+struct Params {
+	src: vec2u,
+	dst: vec2u,
+	scale: vec2f,
+	offset: vec2f,
+	lo: vec2i,
+	hi: vec2i,
+	mean: vec4f,
+	invStd: vec4f,
+	pad: vec4f,
+	order: vec4u,
+};
+
+@group(0) @binding(0) var<uniform> p: Params;
+@group(0) @binding(1) var src: texture_2d<f32>;
+@group(0) @binding(2) var<storage, read_write> dst: array<f32>;
+
+@compute @workgroup_size(16, 16)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+	if (id.x >= p.dst.x || id.y >= p.dst.y) { return; }
+	let x = i32(id.x);
+	let y = i32(id.y);
+	let plane = p.dst.x * p.dst.y;
+	let o = id.y * p.dst.x + id.x;
+	var v = p.pad.xyz;
+	if (x >= p.lo.x && x <= p.hi.x && y >= p.lo.y && y <= p.hi.y) {
+		let maxX = i32(p.src.x) - 1;
+		let maxY = i32(p.src.y) - 1;
+		let sy = max(0.0, (f32(y) + 0.5 - p.offset.y) / p.scale.y - 0.5);
+		let iy0 = min(maxY, i32(floor(sy)));
+		let iy1 = min(maxY, iy0 + 1);
+		let fy = sy - f32(iy0);
+		let sx = max(0.0, (f32(x) + 0.5 - p.offset.x) / p.scale.x - 0.5);
+		let ix0 = min(maxX, i32(floor(sx)));
+		let ix1 = min(maxX, ix0 + 1);
+		let fx = sx - f32(ix0);
+		var rgba =
+			textureLoad(src, vec2i(ix0, iy0), 0) * ((1.0 - fx) * (1.0 - fy)) +
+			textureLoad(src, vec2i(ix1, iy0), 0) * (fx * (1.0 - fy)) +
+			textureLoad(src, vec2i(ix0, iy1), 0) * ((1.0 - fx) * fy) +
+			textureLoad(src, vec2i(ix1, iy1), 0) * (fx * fy);
+		rgba = rgba * 255.0;
+		let s = vec3f(rgba[p.order.x], rgba[p.order.y], rgba[p.order.z]);
+		v = (s - p.mean.xyz) * p.invStd.xyz;
+	}
+	dst[o] = v.x;
+	dst[plane + o] = v.y;
+	dst[2u * plane + o] = v.z;
+}
+`;
+const HASH_WGSL = `
+@group(0) @binding(0) var src: texture_2d<f32>;
+@group(0) @binding(1) var<storage, read_write> acc: array<atomic<u32>, 2>;
+
+var<workgroup> local: array<atomic<u32>, 2>;
+
+@compute @workgroup_size(16, 16)
+fn main(
+	@builtin(global_invocation_id) id: vec3u,
+	@builtin(local_invocation_index) li: u32,
+) {
+	let dim = textureDimensions(src);
+	if (id.x < dim.x && id.y < dim.y) {
+		let c = pack4x8unorm(textureLoad(src, vec2i(id.xy), 0));
+		let i = id.y * dim.x + id.x;
+		let a = (c ^ (i * 0x9e3779b9u)) * 0x85ebca6bu;
+		let b = (c + i * 0xc2b2ae35u) * 0x27d4eb2fu;
+		atomicAdd(&local[0], a ^ (a >> 15u));
+		atomicAdd(&local[1], b ^ (b >> 13u));
+	}
+	workgroupBarrier();
+	if (li == 0u) {
+		atomicAdd(&acc[0], atomicLoad(&local[0]));
+		atomicAdd(&acc[1], atomicLoad(&local[1]));
+	}
+}
+`;
+const PARAMS_BYTES = 112;
+const pipelines = /* @__PURE__ */ new WeakMap();
+var FrameTensorPipeline = class FrameTensorPipeline$1 {
+	tensorPipeline;
+	hashPipeline;
+	params;
+	/** One per device. */
+	static for(device) {
+		let pipeline = pipelines.get(device);
+		if (!pipeline) {
+			pipeline = new FrameTensorPipeline$1(device);
+			pipelines.set(device, pipeline);
+		}
+		return pipeline;
+	}
+	constructor(device) {
+		this.device = device;
+		this.tensorPipeline = device.createComputePipeline({
+			label: "vision_frame_tensor",
+			layout: "auto",
+			compute: {
+				module: device.createShaderModule({ code: TENSOR_WGSL }),
+				entryPoint: "main"
+			}
+		});
+		this.hashPipeline = device.createComputePipeline({
+			label: "vision_frame_hash",
+			layout: "auto",
+			compute: {
+				module: device.createShaderModule({ code: HASH_WGSL }),
+				entryPoint: "main"
+			}
+		});
+		this.params = device.createBuffer({
+			label: "vision_frame_tensor_params",
+			size: PARAMS_BYTES,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+		});
+	}
+	/** Bytes of the NCHW float tensor for `spec`. */
+	static tensorBytes(spec) {
+		return 3 * spec.width * spec.height * 4;
+	}
+	/**
+	* Writes `image` as the model input described by `spec` into `out` (at least
+	* `tensorBytes(spec)`, STORAGE usage). Submits its own command buffer, so it
+	* runs before anything submitted later (e.g. the inference reading `out`).
+	*/
+	toTensor(image, spec, out) {
+		const transform = computeInputTransform(image.width, image.height, spec);
+		const { scaleX, scaleY, offsetX, offsetY } = transform;
+		const params = new ArrayBuffer(PARAMS_BYTES);
+		const u32 = new Uint32Array(params);
+		const f32 = new Float32Array(params);
+		const i32 = new Int32Array(params);
+		u32.set([
+			image.width,
+			image.height,
+			spec.width,
+			spec.height
+		], 0);
+		f32.set([
+			scaleX,
+			scaleY,
+			offsetX,
+			offsetY
+		], 4);
+		i32.set([
+			Math.ceil(offsetX),
+			Math.ceil(offsetY),
+			Math.min(spec.width, Math.floor(offsetX + image.width * scaleX)) - 1,
+			Math.min(spec.height, Math.floor(offsetY + image.height * scaleY)) - 1
+		], 8);
+		const inv = spec.std.map((s) => 1 / s);
+		f32.set([...spec.mean, 0], 12);
+		f32.set([...inv, 0], 16);
+		f32.set([
+			0,
+			1,
+			2
+		].map((c) => (spec.padValue - spec.mean[c]) * inv[c]), 20);
+		u32.set(spec.channels === "bgr" ? [
+			2,
+			1,
+			0,
+			3
+		] : [
+			0,
+			1,
+			2,
+			3
+		], 24);
+		this.device.queue.writeBuffer(this.params, 0, params);
+		const encoder$1 = this.device.createCommandEncoder({ label: "vision_frame_tensor" });
+		const pass = encoder$1.beginComputePass();
+		pass.setPipeline(this.tensorPipeline);
+		pass.setBindGroup(0, this.device.createBindGroup({
+			layout: this.tensorPipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: this.params }
+				},
+				{
+					binding: 1,
+					resource: image.texture.createView()
+				},
+				{
+					binding: 2,
+					resource: { buffer: out }
+				}
+			]
+		}));
+		pass.dispatchWorkgroups(Math.ceil(spec.width / 16), Math.ceil(spec.height / 16));
+		pass.end();
+		this.device.queue.submit([encoder$1.finish()]);
+		return transform;
+	}
+	/** A key that is equal for textures with equal size and pixels. */
+	async contentKey(image) {
+		const acc = this.device.createBuffer({
+			size: 8,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+		});
+		const staging = this.device.createBuffer({
+			size: 8,
+			usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+		});
+		const encoder$1 = this.device.createCommandEncoder({ label: "vision_frame_hash" });
+		const pass = encoder$1.beginComputePass();
+		pass.setPipeline(this.hashPipeline);
+		pass.setBindGroup(0, this.device.createBindGroup({
+			layout: this.hashPipeline.getBindGroupLayout(0),
+			entries: [{
+				binding: 0,
+				resource: image.texture.createView()
+			}, {
+				binding: 1,
+				resource: { buffer: acc }
+			}]
+		}));
+		pass.dispatchWorkgroups(Math.ceil(image.width / 16), Math.ceil(image.height / 16));
+		pass.end();
+		encoder$1.copyBufferToBuffer(acc, 0, staging, 0, 8);
+		this.device.queue.submit([encoder$1.finish()]);
+		await staging.mapAsync(GPUMapMode.READ);
+		const [a, b] = new Uint32Array(staging.getMappedRange().slice(0));
+		staging.unmap();
+		staging.destroy();
+		acc.destroy();
+		return `${image.width}x${image.height}:gpu:${a.toString(36)}:${b.toString(36)}`;
+	}
+};
+/** Reads an 8-bit RGBA/BGRA texture back as RGBA pixels. */
+async function readTexturePixels(image) {
+	const { device, texture, width, height } = image;
+	const unaligned = width * 4;
+	const bytesPerRow = Math.ceil(unaligned / 256) * 256;
+	const staging = device.createBuffer({
+		size: bytesPerRow * height,
+		usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+		label: "vision_frame_readback"
+	});
+	const encoder$1 = device.createCommandEncoder({ label: "vision_frame_readback" });
+	encoder$1.copyTextureToBuffer({ texture }, {
+		buffer: staging,
+		bytesPerRow,
+		rowsPerImage: height
+	}, [
+		width,
+		height,
+		1
+	]);
+	device.queue.submit([encoder$1.finish()]);
+	await staging.mapAsync(GPUMapMode.READ);
+	const mapped = new Uint8Array(staging.getMappedRange());
+	const data = new Uint8ClampedArray(width * height * 4);
+	for (let y = 0; y < height; y++) data.set(mapped.subarray(y * bytesPerRow, y * bytesPerRow + unaligned), y * unaligned);
+	staging.unmap();
+	staging.destroy();
+	if (texture.format.startsWith("bgra")) for (let i = 0; i < data.length; i += 4) {
+		const b = data[i];
+		data[i] = data[i + 2];
+		data[i + 2] = b;
+	}
+	return {
+		data,
+		width,
+		height
+	};
+}
 /** COCO-17 keypoint indices (RTMO output order). */
 const COCO17_KEYPOINTS = {
 	NOSE: 0,
@@ -1474,6 +1772,431 @@ function createNeutralLandmarks() {
 	});
 	return landmarks;
 }
+/**
+* RTMDet-Ins post-processing, done here instead of inside the ONNX graph.
+*
+* The mmdeploy end2end export runs top-k, per-class NMS and mask assembly in
+* the graph and returns a full input-sized mask for each of up to 100
+* detections (40 on a typical frame: ~65 MB of floats). The runner instead
+* cuts the graph before its first data-dependent op (see `RTMDET_INS_HEAD`)
+* and reproduces the tail exactly:
+*
+*   1. top 5000 anchors by their best class score;
+*   2. ONNX NonMaxSuppression per class (IoU > 0.6 suppresses, scores > 0.05,
+*      at most 200 per class);
+*   3. the 100 best (class, box) pairs;
+*   4. masks on demand: a 3-layer dynamic 1×1 conv over the 8 mask features
+*      plus each pixel's offset from the anchor, at 1/8 of the input size.
+*      The logits are upsampled (bilinear) and squashed by the decoder.
+*
+* Constants and layer layout match the export's graph; `models.e2e.test.ts`
+* checks the result against the end2end outputs.
+*/
+/** Head tensors of the mmdeploy RTMDet-Ins exports (all variants). */
+const RTMDET_INS_HEAD = {
+	scores: "/Sigmoid_output_0",
+	boxes: "/Concat_7_output_0",
+	kernels: "/Concat_5_output_0",
+	maskFeatures: "/bbox_head/mask_head/projection/Conv_output_0"
+};
+const PRE_NMS = 5e3;
+const IOU_THRESHOLD = Math.fround(.6);
+const SCORE_FLOOR = Math.fround(.05);
+const MAX_PER_CLASS = 200;
+const MAX_DETECTIONS = 100;
+const STRIDES = [
+	8,
+	16,
+	32
+];
+/** Mask features are at stride 8; relative offsets are divided by stride × 8. */
+const MASK_STRIDE = 8;
+const MASK_CHANNELS = 8;
+const KERNEL_SIZE = 169;
+/** Steps 1–3: the detections the end2end graph would return, best first. */
+function selectInstances(head) {
+	const { scores, boxes, anchors, classes } = head;
+	const best = new Float32Array(anchors);
+	for (let a = 0; a < anchors; a++) {
+		let max = 0;
+		const row = a * classes;
+		for (let c = 0; c < classes; c++) {
+			const s = scores[row + c];
+			if (s > max) max = s;
+		}
+		best[a] = max;
+	}
+	const order = [];
+	for (let a = 0; a < anchors; a++) if (best[a] > SCORE_FLOOR) order.push(a);
+	order.sort((x, y) => best[y] - best[x] || x - y);
+	if (order.length > PRE_NMS) order.length = PRE_NMS;
+	const picked = [];
+	const candidates = [];
+	const kept = [];
+	for (let c = 0; c < classes; c++) {
+		candidates.length = 0;
+		for (const a of order) if (scores[a * classes + c] > SCORE_FLOOR) candidates.push(a);
+		if (candidates.length === 0) continue;
+		candidates.sort((x, y) => scores[y * classes + c] - scores[x * classes + c] || x - y);
+		kept.length = 0;
+		for (const a of candidates) {
+			if (kept.length >= MAX_PER_CLASS) break;
+			let suppressed = false;
+			for (const k of kept) if (iou(boxes, a, k) > IOU_THRESHOLD) {
+				suppressed = true;
+				break;
+			}
+			if (!suppressed) {
+				kept.push(a);
+				picked.push({
+					anchor: a,
+					classIndex: c,
+					score: scores[a * classes + c]
+				});
+			}
+		}
+	}
+	picked.sort((x, y) => y.score - x.score);
+	if (picked.length > MAX_DETECTIONS) picked.length = MAX_DETECTIONS;
+	return picked;
+}
+function iou(boxes, a, b) {
+	const a0 = boxes[a * 4];
+	const a1 = boxes[a * 4 + 1];
+	const a2 = boxes[a * 4 + 2];
+	const a3 = boxes[a * 4 + 3];
+	const b0 = boxes[b * 4];
+	const b1 = boxes[b * 4 + 1];
+	const b2 = boxes[b * 4 + 2];
+	const b3 = boxes[b * 4 + 3];
+	const w = Math.min(a2, b2) - Math.max(a0, b0);
+	const h = Math.min(a3, b3) - Math.max(a1, b1);
+	if (w <= 0 || h <= 0) return 0;
+	const inter = w * h;
+	const union = (a2 - a0) * (a3 - a1) + (b2 - b0) * (b3 - b1) - inter;
+	return union > 0 ? inter / union : 0;
+}
+/** Anchor position and stride, in input pixels (mmdet point priors, offset 0). */
+function anchorPrior(anchor, inputWidth, inputHeight) {
+	let base = 0;
+	for (const stride of STRIDES) {
+		const cols = Math.ceil(inputWidth / stride);
+		const count = cols * Math.ceil(inputHeight / stride);
+		if (anchor < base + count) {
+			const i = anchor - base;
+			return {
+				x: i % cols * stride,
+				y: Math.floor(i / cols) * stride,
+				stride
+			};
+		}
+		base += count;
+	}
+	throw new RangeError(`anchor ${anchor} is out of range`);
+}
+/**
+* Step 4: mask logits for one anchor, `maskHeight × maskWidth`, row-major.
+* Writes into `out` when it is large enough.
+*/
+function maskLogits(head, anchor, out) {
+	const { kernels, maskFeatures, maskWidth: mw, maskHeight: mh } = head;
+	const plane = mw * mh;
+	const logits = out && out.length >= plane ? out : new Float32Array(plane);
+	const prior = anchorPrior(anchor, head.inputWidth, head.inputHeight);
+	const k = kernels.subarray(anchor * KERNEL_SIZE, (anchor + 1) * KERNEL_SIZE);
+	const w1 = 0;
+	const w2 = 80;
+	const w3 = 144;
+	const b1 = 152;
+	const b2 = 160;
+	const b3 = 168;
+	const scale = 1 / (prior.stride * MASK_STRIDE);
+	const input = new Float32Array(2 + MASK_CHANNELS);
+	const hidden1 = new Float32Array(8);
+	const hidden2 = new Float32Array(8);
+	for (let y = 0; y < mh; y++) {
+		const relY = (prior.y - y * MASK_STRIDE) * scale;
+		for (let x = 0; x < mw; x++) {
+			const p = y * mw + x;
+			input[0] = (prior.x - x * MASK_STRIDE) * scale;
+			input[1] = relY;
+			for (let c = 0; c < MASK_CHANNELS; c++) input[2 + c] = maskFeatures[c * plane + p];
+			for (let o = 0; o < 8; o++) {
+				let sum$1 = k[b1 + o];
+				const row = w1 + o * 10;
+				for (let i = 0; i < 10; i++) sum$1 += k[row + i] * input[i];
+				hidden1[o] = sum$1 > 0 ? sum$1 : 0;
+			}
+			for (let o = 0; o < 8; o++) {
+				let sum$1 = k[b2 + o];
+				const row = w2 + o * 8;
+				for (let i = 0; i < 8; i++) sum$1 += k[row + i] * hidden1[i];
+				hidden2[o] = sum$1 > 0 ? sum$1 : 0;
+			}
+			let sum = k[b3];
+			for (let i = 0; i < 8; i++) sum += k[w3 + i] * hidden2[i];
+			logits[p] = sum;
+		}
+	}
+	return logits;
+}
+/**
+* Minimal ONNX protobuf wire-format helpers: split a message into fields,
+* read strings, write length-delimited fields. Only what the graph editors
+* (onnx-subgraph.ts, onnx-float16.ts) need; unknown fields are copied as raw
+* bytes, so nothing else in a model is touched.
+*/
+const MODEL_GRAPH = 7;
+const GRAPH_NODE = 1;
+const GRAPH_INITIALIZER = 5;
+const GRAPH_INPUT = 11;
+const GRAPH_OUTPUT = 12;
+const GRAPH_VALUE_INFO = 13;
+const NODE_INPUT = 1;
+const NODE_OUTPUT$1 = 2;
+const VALUE_INFO_NAME = 1;
+const TENSOR_NAME = 8;
+const WIRE_VARINT = 0;
+const WIRE_I64 = 1;
+const WIRE_LEN = 2;
+const WIRE_I32 = 5;
+function readVarint(buf, pos) {
+	let value = 0;
+	let scale = 1;
+	for (;;) {
+		if (pos >= buf.length) throw new Error("ONNX model: truncated varint");
+		const byte = buf[pos++];
+		value += (byte & 127) * scale;
+		if (byte < 128) return [value, pos];
+		scale *= 128;
+	}
+}
+function fields(buf) {
+	const out = [];
+	let pos = 0;
+	while (pos < buf.length) {
+		const start = pos;
+		const [tag, afterTag] = readVarint(buf, pos);
+		pos = afterTag;
+		const number = Math.floor(tag / 8);
+		const wire = tag & 7;
+		let body = buf.subarray(pos, pos);
+		if (wire === WIRE_VARINT) pos = readVarint(buf, pos)[1];
+		else if (wire === WIRE_I64) pos += 8;
+		else if (wire === WIRE_I32) pos += 4;
+		else if (wire === WIRE_LEN) {
+			const [length, afterLength] = readVarint(buf, pos);
+			body = buf.subarray(afterLength, afterLength + length);
+			pos = afterLength + length;
+		} else throw new Error(`ONNX model: unsupported wire type ${wire}`);
+		if (pos > buf.length) throw new Error("ONNX model: truncated field");
+		out.push({
+			number,
+			wire,
+			raw: buf.subarray(start, pos),
+			body
+		});
+	}
+	return out;
+}
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+function strings(buf, number) {
+	return fields(buf).filter((f) => f.number === number && f.wire === WIRE_LEN).map((f) => decoder.decode(f.body));
+}
+function firstString(buf, number) {
+	return strings(buf, number)[0];
+}
+function varint(value) {
+	const bytes = [];
+	while (value >= 128) {
+		bytes.push(value % 128 | 128);
+		value = Math.floor(value / 128);
+	}
+	bytes.push(value);
+	return bytes;
+}
+function lengthDelimited(number, payload) {
+	const head = [...varint(number * 8 + WIRE_LEN), ...varint(payload.length)];
+	const out = new Uint8Array(head.length + payload.length);
+	out.set(head, 0);
+	out.set(payload, head.length);
+	return out;
+}
+function concat(parts) {
+	const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+	let offset = 0;
+	for (const part of parts) {
+		out.set(part, offset);
+		offset += part.length;
+	}
+	return out;
+}
+/**
+* Cuts an ONNX model down to the nodes that compute a chosen set of tensors,
+* which become the graph's outputs. Works on the protobuf wire format directly
+* (only the fields it needs are decoded; everything else is copied byte for
+* byte), so it needs no protobuf library and keeps the weights untouched.
+*
+* Used to run a detector's fixed-shape body on the GPU and do its
+* data-dependent tail (top-k, NMS, mask assembly) ourselves.
+*/
+/** ValueInfoProto for a float tensor of unknown shape. */
+function floatOutput(name) {
+	const typeProto = lengthDelimited(1, new Uint8Array([8, 1]));
+	return concat([lengthDelimited(VALUE_INFO_NAME, encoder.encode(name)), lengthDelimited(2, typeProto)]);
+}
+/**
+* Returns a model whose outputs are `outputs` (tensors of the original graph),
+* keeping only the nodes, initializers and inputs needed to compute them.
+* Output types come from the graph's value_info when present; otherwise they
+* are declared as float tensors.
+*/
+function extractSubgraph(model, outputs) {
+	const modelFields = fields(model);
+	const graphField = modelFields.find((f) => f.number === MODEL_GRAPH && f.wire === WIRE_LEN);
+	if (!graphField) throw new Error("ONNX model has no graph");
+	const graphFields = fields(graphField.body);
+	const nodes = graphFields.filter((f) => f.number === GRAPH_NODE).map((f) => ({
+		field: f,
+		inputs: strings(f.body, NODE_INPUT),
+		outputs: strings(f.body, NODE_OUTPUT$1)
+	}));
+	const producer = /* @__PURE__ */ new Map();
+	nodes.forEach((node, index) => {
+		for (const name of node.outputs) producer.set(name, index);
+	});
+	const keepNode = /* @__PURE__ */ new Set();
+	const needed = /* @__PURE__ */ new Set();
+	const stack = [...outputs];
+	for (const name of outputs) if (!producer.has(name)) throw new Error(`ONNX model has no tensor '${name}'`);
+	while (stack.length > 0) {
+		const name = stack.pop();
+		if (needed.has(name)) continue;
+		needed.add(name);
+		const index = producer.get(name);
+		if (index === void 0 || keepNode.has(index)) continue;
+		keepNode.add(index);
+		for (const input of nodes[index].inputs) if (input) stack.push(input);
+	}
+	const valueInfo = /* @__PURE__ */ new Map();
+	for (const f of graphFields) {
+		if (f.number !== GRAPH_VALUE_INFO) continue;
+		const name = firstString(f.body, VALUE_INFO_NAME);
+		if (name !== void 0) valueInfo.set(name, f.body);
+	}
+	const parts = [];
+	let nodeIndex = 0;
+	for (const f of graphFields) switch (f.number) {
+		case GRAPH_NODE:
+			if (keepNode.has(nodeIndex)) parts.push(f.raw);
+			nodeIndex++;
+			break;
+		case GRAPH_INITIALIZER: {
+			const name = firstString(f.body, TENSOR_NAME);
+			if (name !== void 0 && needed.has(name)) parts.push(f.raw);
+			break;
+		}
+		case GRAPH_INPUT:
+		case GRAPH_VALUE_INFO: {
+			const name = firstString(f.body, VALUE_INFO_NAME);
+			if (name !== void 0 && needed.has(name)) parts.push(f.raw);
+			break;
+		}
+		case GRAPH_OUTPUT: break;
+		default: parts.push(f.raw);
+	}
+	for (const name of outputs) parts.push(lengthDelimited(GRAPH_OUTPUT, valueInfo.get(name) ?? floatOutput(name)));
+	const graph = concat(parts);
+	return concat(modelFields.map((f) => f === graphField ? lengthDelimited(MODEL_GRAPH, graph) : f.raw));
+}
+/**
+* onnxruntime-web 1.30's WebGPU EP computes grouped convolutions wrong in its
+* default NHWC layout when a group has more than one channel and the count
+* isn't a multiple of 4 (RTMO's head: 18 per group → duplicate skeletons).
+* NCHW is correct but ~30% slower, so only models with such a convolution get
+* it. Depthwise convolutions (one channel per group: RTMDet-Ins, Selfie) are
+* fine in NHWC.
+*/
+const NODE_OP_TYPE = 4;
+const NODE_ATTRIBUTE = 5;
+const NODE_OUTPUT = 2;
+const ATTR_NAME = 1;
+const ATTR_I = 3;
+const ATTR_T = 5;
+const TENSOR_DIMS = 1;
+function varintValues(field) {
+	const values = [];
+	if (field.wire === WIRE_LEN) {
+		let pos = 0;
+		while (pos < field.body.length) {
+			const [value, next] = readVarint(field.body, pos);
+			values.push(value);
+			pos = next;
+		}
+	} else if (field.wire === WIRE_VARINT) {
+		let pos = 0;
+		pos = readVarint(field.raw, pos)[1];
+		values.push(readVarint(field.raw, pos)[0]);
+	}
+	return values;
+}
+function tensorDims(tensor) {
+	return fields(tensor).filter((f) => f.number === TENSOR_DIMS).flatMap(varintValues);
+}
+/**
+* True when the model has a grouped convolution the NHWC kernels get wrong,
+* and when it can't be read (NCHW is always correct).
+*/
+function needsNchwLayout(model) {
+	let graph;
+	try {
+		graph = fields(model).find((f) => f.number === MODEL_GRAPH && f.wire === WIRE_LEN);
+	} catch {
+		return true;
+	}
+	if (!graph) return true;
+	const dims = /* @__PURE__ */ new Map();
+	const convs = [];
+	for (const f of fields(graph.body)) if (f.number === GRAPH_INITIALIZER) {
+		const name = firstString(f.body, TENSOR_NAME);
+		if (name !== void 0) dims.set(name, tensorDims(f.body));
+	} else if (f.number === GRAPH_NODE) {
+		const op = firstString(f.body, NODE_OP_TYPE);
+		if (op !== "Conv" && op !== "Constant") continue;
+		const attributes = fields(f.body).filter((a) => a.number === NODE_ATTRIBUTE).map((a) => a.body);
+		if (op === "Constant") {
+			const value = attributes.find((a) => firstString(a, ATTR_NAME) === "value");
+			const tensor = value && fields(value).find((a) => a.number === ATTR_T);
+			const output$1 = strings(f.body, NODE_OUTPUT)[0];
+			if (tensor && output$1) dims.set(output$1, tensorDims(tensor.body));
+			continue;
+		}
+		const groupAttr = attributes.find((a) => firstString(a, ATTR_NAME) === "group");
+		const groupField = groupAttr && fields(groupAttr).find((a) => a.number === ATTR_I);
+		const group = groupField ? varintValues(groupField)[0] ?? 1 : 1;
+		const weight = strings(f.body, NODE_INPUT)[1];
+		if (group > 1 && weight) convs.push({
+			weight,
+			group
+		});
+	}
+	return convs.some(({ weight }) => {
+		const perGroup = dims.get(weight)?.[1];
+		return perGroup !== void 0 && perGroup > 1 && perGroup % 4 !== 0;
+	});
+}
+/**
+* Browser / WebGPU session provider .
+*
+* Mirrors `NodeSessionProvider` but uses `onnxruntime-web` with the WebGPU execution provider
+* and a WASM fallback. The ORT module is imported lazily behind an injectable loader, so:
+*  - the Node core entry never pulls browser code, and
+*  - unit tests can run fully offline with a fake module.
+*
+* `onnxruntime-web` is an OPTIONAL peer dependency — consumers of `@framefields/vision/web`
+* provide it; the main `@framefields/vision` entry never touches it.
+*/
 const ORT_WEB_SPECIFIER = "onnxruntime-web";
 const defaultLoader = () => import(
 	/* @vite-ignore */
@@ -1485,10 +2208,12 @@ var WebGPUProvider = class {
 	_providers;
 	_wasmFallback;
 	_ortPromise;
+	device;
 	constructor(options = {}) {
 		this._loader = options.loader ?? defaultLoader;
 		this._providers = options.executionProviders ?? ["webgpu", "wasm"];
 		this._wasmFallback = options.wasmFallback !== false;
+		this.device = options.device;
 	}
 	ort() {
 		if (!this._ortPromise) this._ortPromise = this._loader().catch((err) => {
@@ -1501,8 +2226,10 @@ var WebGPUProvider = class {
 		const ort = await this.ort();
 		let session;
 		try {
+			const device = this.device;
+			const layout = needsNchwLayout(modelBytes) ? "NCHW" : "NHWC";
 			session = await ort.InferenceSession.create(modelBytes, {
-				executionProviders: [...this._providers],
+				executionProviders: this._providers.map((name) => withProviderOptions(name, device, layout)),
 				graphOptimizationLevel: "all",
 				logSeverityLevel: 3
 			});
@@ -1517,11 +2244,15 @@ var WebGPUProvider = class {
 		return {
 			run: async (input) => {
 				const inputName = session.inputNames.includes(input.name) ? input.name : session.inputNames[0] ?? input.name;
-				const results = await session.run({ [inputName]: new ort.Tensor("float32", input.data, [...input.dims]) });
+				const tensor = input.gpuBuffer && ort.Tensor.fromGpuBuffer ? ort.Tensor.fromGpuBuffer(input.gpuBuffer, {
+					dataType: "float32",
+					dims: [...input.dims]
+				}) : new ort.Tensor("float32", input.data, [...input.dims]);
+				const results = await session.run({ [inputName]: tensor });
 				const outputs = {};
-				for (const [name, tensor] of Object.entries(results)) outputs[name] = {
-					data: tensor.data,
-					dims: [...tensor.dims]
+				for (const [name, tensor$1] of Object.entries(results)) outputs[name] = {
+					data: tensor$1.data,
+					dims: [...tensor$1.dims]
 				};
 				return outputs;
 			},
@@ -1531,30 +2262,62 @@ var WebGPUProvider = class {
 		};
 	}
 };
+/**
+* The WebGPU EP runs in NCHW. Its default NHWC layout computes grouped convolutions wrong
+* when the channels per group aren't a multiple of 4 (onnxruntime-web 1.30) — RTMO's head
+* has group=8 convs over 104 channels (13 per group), which turned one dancer into several
+* skeletons. NCHW matches the CPU EP on every pinned model.
+*/
+function withProviderOptions(name, device, preferredLayout) {
+	if (name !== "webgpu") return name;
+	return device ? {
+		name,
+		preferredLayout,
+		device
+	} : {
+		name,
+		preferredLayout
+	};
+}
 const ORT_WEBGPU_SPECIFIER = "onnxruntime-web/webgpu";
 const WEBGPU_SPECIFIER = "webgpu";
 let nodeWebGPUReady;
+/** CPU rasterizers (lavapipe, llvmpipe, SwiftShader): slower than the CPU EP. */
+const SOFTWARE_ADAPTER = /llvmpipe|lavapipe|swiftshader|software/i;
 /**
-* Ensure `globalThis.navigator.gpu` exists. In the renderer this is already the
-* Dawn device; otherwise imports the `webgpu` (Dawn) package and installs its
-* globals plus an adapter, which is what onnxruntime-web's WebGPU EP needs.
+* Ensure `globalThis.navigator.gpu` exists and has a hardware adapter that
+* onnxruntime-web's WebGPU EP can use. In the renderer this is already the Dawn
+* device; otherwise imports the `webgpu` (Dawn) package and installs its
+* globals. Rejects when the only adapter is a software rasterizer.
 */
 function ensureNodeWebGPU() {
 	if (!nodeWebGPUReady) {
 		nodeWebGPUReady = (async () => {
 			const g = globalThis;
-			if (g.navigator?.gpu) return;
-			const { create, globals } = await import(
-				/* @vite-ignore */
-				WEBGPU_SPECIFIER
+			if (!g.navigator?.gpu) {
+				const { create, globals } = await import(
+					/* @vite-ignore */
+					WEBGPU_SPECIFIER
 );
-			Object.assign(globalThis, globals);
-			const nav = g.navigator ??= {};
-			Object.defineProperty(nav, "gpu", {
-				value: create([]),
-				configurable: true,
-				writable: true
-			});
+				Object.assign(globalThis, globals);
+				g.navigator ??= {};
+				Object.defineProperty(g.navigator, "gpu", {
+					value: create([]),
+					configurable: true,
+					writable: true
+				});
+			}
+			const adapter = await (g.navigator?.gpu).requestAdapter({ powerPreference: "high-performance" });
+			if (!adapter) throw new Error("No WebGPU adapter.");
+			const info = adapter.info ?? {};
+			const name = [
+				info.vendor,
+				info.architecture,
+				info.device,
+				info.description
+			].filter(Boolean).join(" ");
+			if (adapter.isFallbackAdapter === true || info.isFallbackAdapter === true || SOFTWARE_ADAPTER.test(name)) throw new Error(`WebGPU adapter is a software rasterizer (${name}).`);
+			patchSupportedFeatures(adapter.features);
 		})();
 		nodeWebGPUReady.catch(() => {
 			nodeWebGPUReady = void 0;
@@ -1562,8 +2325,39 @@ function ensureNodeWebGPU() {
 	}
 	return nodeWebGPUReady;
 }
+/**
+* Dawn's Node `GPUSupportedFeatures` has `has`/`keys`/`size` but no `forEach`,
+* which onnxruntime-web's WebGPU build calls on adapter and device features
+* (they share the class). Adds the missing set-like methods once.
+*/
+function patchSupportedFeatures(features) {
+	const proto = Object.getPrototypeOf(features);
+	if (!proto || typeof proto.keys !== "function") return;
+	if (typeof proto.forEach !== "function") Object.defineProperty(proto, "forEach", {
+		value(callback, thisArg) {
+			for (const key of this.keys()) callback.call(thisArg, key, key, this);
+		},
+		configurable: true,
+		writable: true
+	});
+	if (typeof proto.values !== "function") Object.defineProperty(proto, "values", {
+		value() {
+			return this.keys();
+		},
+		configurable: true,
+		writable: true
+	});
+	if (typeof proto.entries !== "function") Object.defineProperty(proto, "entries", {
+		*value() {
+			for (const key of this.keys()) yield [key, key];
+		},
+		configurable: true,
+		writable: true
+	});
+}
 var NodeWebGPUProvider = class {
 	kind = "webgpu";
+	device;
 	_inner;
 	constructor(options = {}) {
 		const loader = options.loader ?? (async () => {
@@ -1573,8 +2367,10 @@ var NodeWebGPUProvider = class {
 				ORT_WEBGPU_SPECIFIER
 );
 			if (mod.env?.wasm) mod.env.wasm.numThreads = 1;
+			if (mod.env?.webgpu) mod.env.webgpu.powerPreference = "high-performance";
 			return mod;
 		});
+		this.device = options.device;
 		this._inner = new WebGPUProvider({
 			wasmFallback: false,
 			...options,
@@ -1586,41 +2382,163 @@ var NodeWebGPUProvider = class {
 	}
 };
 let defaultProvider;
+let visionDevice;
+/**
+* The GPU device the default provider runs WebGPU sessions on — the renderer's,
+* so frames can go from its textures into the models without a CPU round trip.
+* Applies to sessions created afterwards; without it, onnxruntime-web creates
+* its own device.
+*/
+function setVisionDevice(device) {
+	visionDevice = device;
+}
+/**
+* Hosts (the renderer) register a listener under this symbol to log the
+* backend; a global keeps it working however the packages are bundled.
+*/
+const VISION_BACKEND_LISTENER = Symbol.for("framefields.vision.backend");
+function reportBackend(info) {
+	const listener = globalThis[VISION_BACKEND_LISTENER];
+	if (typeof listener === "function") try {
+		listener(info);
+	} catch {}
+}
+function requestedVisionBackend() {
+	const value = typeof process !== "undefined" ? process.env.FRAMEFIELDS_VISION_PROVIDER?.trim().toLowerCase() : void 0;
+	return value === "webgpu" || value === "cuda" || value === "cpu" ? value : "auto";
+}
 /**
 * Prefers the GPU (onnxruntime-web's WebGPU EP on the process's WebGPU device —
 * the Dawn device the renderer already creates, or one this ensures) and falls
 * back to the CPU provider (onnxruntime-node) when a WebGPU session cannot be
-* created: no device, no Dawn, or the EP unavailable. The choice is made on the
-* first session and reused for the runner's lifetime.
+* created: no hardware adapter, no Dawn, or onnxruntime-web not installed. The
+* choice is made on the first session and kept.
+*
+* `FRAMEFIELDS_VISION_PROVIDER` forces one backend instead: `webgpu`, `cpu`, or
+* `cuda` (onnxruntime-node's CUDA EP on Linux x64; needs the CUDA 12 and cuDNN 9
+* libraries). A forced backend that fails throws instead of falling back.
 */
 var AutoSessionProvider = class {
 	_resolved;
+	_resolving;
 	get kind() {
 		return this._resolved?.kind ?? "webgpu";
 	}
+	get device() {
+		return this._resolved?.device;
+	}
 	async createSession(modelBytes) {
-		if (!this._resolved) {
-			const webgpu = new NodeWebGPUProvider({ wasmFallback: false });
-			try {
-				const session = await webgpu.createSession(modelBytes);
-				this._resolved = webgpu;
-				return session;
-			} catch {
-				this._resolved = new NodeSessionProvider();
-			}
+		if (this._resolved) return this._resolved.createSession(modelBytes);
+		if (!this._resolving) {
+			this._resolving = this.resolve(modelBytes);
+			this._resolving.catch(() => {
+				this._resolving = void 0;
+			});
+			const { provider: provider$1, first } = await this._resolving;
+			this._resolved = provider$1;
+			if (first) return first;
+			return provider$1.createSession(modelBytes);
+		}
+		const { provider } = await this._resolving;
+		return provider.createSession(modelBytes);
+	}
+	async resolve(modelBytes) {
+		const backend = requestedVisionBackend();
+		if (backend === "cpu") {
+			reportBackend({
+				backend: "cpu",
+				sharedDevice: false,
+				reason: "FRAMEFIELDS_VISION_PROVIDER=cpu"
+			});
+			return { provider: new NodeSessionProvider() };
+		}
+		if (backend === "cuda") {
+			reportBackend({
+				backend: "cuda",
+				sharedDevice: false
+			});
+			return { provider: new NodeSessionProvider({ executionProviders: ["cuda", "cpu"] }) };
+		}
+		const webgpu = new NodeWebGPUProvider({
+			wasmFallback: false,
+			device: visionDevice
+		});
+		try {
+			const first = await webgpu.createSession(modelBytes);
+			reportBackend({
+				backend: "webgpu",
+				sharedDevice: !!visionDevice
+			});
+			return {
+				provider: webgpu,
+				first
+			};
+		} catch (err) {
+			if (backend === "webgpu") throw err;
+			reportBackend({
+				backend: "cpu",
+				sharedDevice: false,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+			return { provider: new NodeSessionProvider() };
 		}
-		return this._resolved.createSession(modelBytes);
 	}
 };
+let processProvider;
 /**
 * The provider for a runner created without one: GPU if possible, otherwise CPU.
+* One per process, so the GPU probe runs once however many runners there are.
 */
 function createDefaultSessionProvider() {
-	return defaultProvider?.() ?? new AutoSessionProvider();
+	if (defaultProvider) return defaultProvider();
+	processProvider ??= new AutoSessionProvider();
+	return processProvider;
+}
+/**
+* CPUs this process may use: the affinity mask, capped by a cgroup CPU quota
+* (containers). ONNX Runtime sizes its thread pool from the host's cores, which
+* oversubscribes a container limited to fewer CPUs than the host has.
+*/
+async function availableCpus() {
+	const os$1 = await import("node:os");
+	const cpus = typeof os$1.availableParallelism === "function" ? os$1.availableParallelism() : os$1.cpus().length;
+	const quota = await cgroupCpuQuota();
+	return Math.max(1, quota !== void 0 ? Math.min(cpus, quota) : cpus);
+}
+/** cgroup v2 `cpu.max` or v1 `cpu.cfs_quota_us`, in CPUs (rounded up); undefined when unlimited. */
+async function cgroupCpuQuota() {
+	if (typeof process === "undefined" || process.platform !== "linux") return;
+	const { readFile: readFile$1 } = await import("node:fs/promises");
+	const read = (path$1) => readFile$1(path$1, "utf8").then((text) => text.trim(), () => void 0);
+	const toCpus = (quota, period) => quota > 0 && period > 0 ? Math.ceil(quota / period) : void 0;
+	const v2 = await read("/sys/fs/cgroup/cpu.max");
+	if (v2 !== void 0) {
+		const [quota, period] = v2.split(/\s+/);
+		return quota === "max" ? void 0 : toCpus(Number(quota), Number(period));
+	}
+	const v1Quota = await read("/sys/fs/cgroup/cpu/cpu.cfs_quota_us");
+	const v1Period = await read("/sys/fs/cgroup/cpu/cpu.cfs_period_us");
+	if (v1Quota === void 0 || v1Period === void 0) return void 0;
+	return toCpus(Number(v1Quota), Number(v1Period));
+}
+/**
+* Intra-op threads for CPU sessions: `FRAMEFIELDS_VISION_THREADS` when set,
+* else the available CPUs on Linux (where containers cap them), else ONNX
+* Runtime's own default (undefined).
+*/
+async function cpuSessionThreads() {
+	const env = typeof process !== "undefined" ? Number.parseInt(process.env.FRAMEFIELDS_VISION_THREADS ?? "", 10) : NaN;
+	if (Number.isFinite(env) && env > 0) return env;
+	if (typeof process === "undefined" || process.platform !== "linux") return;
+	return availableCpus();
 }
 /** onnxruntime-node provider. The native module is imported lazily on first session. */
 var NodeSessionProvider = class {
 	kind = "node";
+	_executionProviders;
+	constructor(options = {}) {
+		this._executionProviders = options.executionProviders ?? ["cpu"];
+	}
 	ortPromise;
 	async ort() {
 		if (!this.ortPromise) this.ortPromise = import("onnxruntime-node").catch((err) => {
@@ -1631,9 +2549,14 @@ var NodeSessionProvider = class {
 	}
 	async createSession(modelBytes) {
 		const ort = await this.ort();
+		const threads = await cpuSessionThreads();
 		const session = await ort.InferenceSession.create(modelBytes, {
-			executionProviders: ["cpu"],
-			graphOptimizationLevel: "all"
+			executionProviders: [...this._executionProviders],
+			graphOptimizationLevel: "all",
+			...threads !== void 0 ? {
+				intraOpNumThreads: threads,
+				interOpNumThreads: 1
+			} : {}
 		});
 		return {
 			run: async (input) => {
@@ -1652,6 +2575,10 @@ var NodeSessionProvider = class {
 		};
 	}
 };
+function isGpuImage(image) {
+	return image.texture !== void 0;
+}
+const MAX_INSTANCE_PASSES = 4;
 /**
 * Lazy vision runner.
 *
@@ -1666,38 +2593,58 @@ var VisionRunner = class VisionRunner$1 {
 	classes;
 	maskThreshold;
 	featherRadius;
-	_store;
-	_provider;
-	_sessions = /* @__PURE__ */ new Map();
-	_tensorScratch = /* @__PURE__ */ new Map();
-	/** One RTMDet-Ins pass per frame buffer, shared by detect() and segment(). */
-	_instancePass;
-	constructor(options) {
+	_core;
+	/** False for derived runners: their sessions belong to the runner they came from. */
+	_ownsCore;
+	constructor(options, core) {
 		this.variant = options.variant ?? "s";
 		this.confidence = options.confidence ?? .3;
 		this.classes = options.classes;
 		this.maskThreshold = options.maskThreshold ?? .5;
 		this.featherRadius = options.featherRadius;
-		this._store = options.store ?? new VisionModelStore({
-			modelsDir: options.modelsDir,
-			baseUrl: options.baseUrl,
-			timeoutMs: options.timeoutMs,
-			onProgress: options.onProgress
-		});
-		this._provider = options.provider ?? createDefaultSessionProvider();
+		this._ownsCore = core === void 0;
+		this._core = core ?? {
+			store: options.store ?? new VisionModelStore({
+				modelsDir: options.modelsDir,
+				baseUrl: options.baseUrl,
+				timeoutMs: options.timeoutMs,
+				onProgress: options.onProgress
+			}),
+			provider: options.provider ?? createDefaultSessionProvider(),
+			sessions: /* @__PURE__ */ new Map(),
+			tensorScratch: /* @__PURE__ */ new Map(),
+			runQueue: /* @__PURE__ */ new Map(),
+			gpuInputs: /* @__PURE__ */ new Map(),
+			instancePasses: []
+		};
 	}
 	/** Cheap: no downloads, no sessions, no side effects. */
 	static create(options = {}) {
 		return new VisionRunner$1(options);
 	}
+	/**
+	* A runner with other decode options (confidence, classes, mask threshold,
+	* feather) that shares this runner's models, sessions and per-frame RTMDet-Ins
+	* pass — e.g. one per layer, without loading a model twice. Its `close()` is a
+	* no-op; closing this runner releases the shared sessions.
+	*/
+	derive(options) {
+		return new VisionRunner$1({
+			variant: this.variant,
+			confidence: options.confidence ?? this.confidence,
+			classes: "classes" in options ? options.classes : this.classes,
+			maskThreshold: options.maskThreshold ?? this.maskThreshold,
+			featherRadius: "featherRadius" in options ? options.featherRadius : this.featherRadius
+		}, this._core);
+	}
 	get modelsDir() {
-		return this._store.modelsDir;
+		return this._core.store.modelsDir;
 	}
 	/** Every registry model keyed to its current download state (downloaded → "ready"). */
 	get downloadStatus() {
 		const statuses = /* @__PURE__ */ new Map();
 		for (const key of Object.keys(VISION_MODELS)) statuses.set(key, "pending");
-		for (const [key, status] of this._store.statuses()) statuses.set(key, status);
+		for (const [key, status] of this._core.store.statuses()) statuses.set(key, status);
 		return statuses;
 	}
 	/** The model serving `task` (matte depends on frame aspect; defaults to square). */
@@ -1714,7 +2661,7 @@ var VisionRunner = class VisionRunner$1 {
 			keys.add("selfie-square");
 			keys.add("selfie-landscape");
 		} else keys.add(this.modelKeyFor(task));
-		await this._store.preload([...keys]);
+		await this._core.store.preload([...keys]);
 		await Promise.all([...keys].map((key) => this.session(key)));
 	}
 	/** COCO-80 boxes (sorted by score, source pixels). Masks are not decoded. */
@@ -1722,7 +2669,8 @@ var VisionRunner = class VisionRunner$1 {
 		const pass = await this.instancePass(image);
 		return decodeRtmdetIns({
 			...pass.outputs,
-			masks: void 0
+			masks: void 0,
+			maskPlane: void 0
 		}, this.instanceDecodeOptions(image, pass.transform)).detections;
 	}
 	/** COCO-80 boxes plus a frame-aligned soft mask per instance. */
@@ -1761,35 +2709,35 @@ var VisionRunner = class VisionRunner$1 {
 		});
 	}
 	close() {
-		for (const promise of this._sessions.values()) promise.then((session) => session.release()).catch(() => void 0);
-		this._sessions.clear();
-		this._instancePass = void 0;
-		this._store.clearMemoryCache();
-	}
-	instancePass(image) {
-		if (this._instancePass?.frame === image.data) return this._instancePass.result;
+		if (!this._ownsCore) return;
+		const core = this._core;
+		for (const promise of core.sessions.values()) promise.then((session) => session.release()).catch(() => void 0);
+		core.sessions.clear();
+		core.runQueue.clear();
+		for (const { buffer } of core.gpuInputs.values()) buffer.destroy();
+		core.gpuInputs.clear();
+		core.instancePasses.length = 0;
+		core.store.clearMemoryCache();
+	}
+	async instancePass(image) {
+		const passes = this._core.instancePasses;
+		const content = isGpuImage(image) ? await FrameTensorPipeline.for(image.device).contentKey(image) : contentKey(image);
+		const byContent = passes.find((pass$1) => pass$1.content === content);
+		if (byContent) return byContent.result;
 		const key = this.modelKeyFor("segment");
-		const result = this.infer(key, image).then(({ outputs, transform }) => {
-			const dets = output(outputs, "dets", key);
-			const masks = output(outputs, "masks", key);
-			return {
-				transform,
-				outputs: {
-					dets: dets.data,
-					labels: output(outputs, "labels", key).data,
-					masks: masks.data,
-					count: dets.dims[1] ?? 0,
-					maskHeight: masks.dims[masks.dims.length - 2] ?? 0,
-					maskWidth: masks.dims[masks.dims.length - 1] ?? 0
-				}
-			};
-		});
-		this._instancePass = {
-			frame: image.data,
+		const result = this.infer(key, image).then(({ outputs, transform }) => ({
+			transform,
+			outputs: RTMDET_INS_HEAD.scores in outputs ? headPassOutputs(outputs, key, transform) : end2endPassOutputs(outputs, key)
+		}));
+		const pass = {
+			content,
 			result
 		};
+		passes.push(pass);
+		if (passes.length > MAX_INSTANCE_PASSES) passes.shift();
 		result.catch(() => {
-			if (this._instancePass?.result === result) this._instancePass = void 0;
+			const index = passes.indexOf(pass);
+			if (index >= 0) passes.splice(index, 1);
 		});
 		return result;
 	}
@@ -1805,44 +2753,178 @@ var VisionRunner = class VisionRunner$1 {
 			...this.featherRadius !== void 0 ? { featherRadius: this.featherRadius } : {}
 		};
 	}
-	async infer(key, image) {
+	/**
+	* Runs one model on one image. Runs of the same model are queued: they share
+	* the input scratch buffer, and one run already uses the session's threads.
+	*/
+	infer(key, image) {
+		const queue = this._core.runQueue;
+		const run = (queue.get(key) ?? Promise.resolve()).then(() => this.inferNow(key, image), () => this.inferNow(key, image));
+		const tail = run.catch(() => void 0);
+		queue.set(key, tail);
+		tail.then(() => {
+			if (queue.get(key) === tail) queue.delete(key);
+		});
+		return run;
+	}
+	async inferNow(key, frame) {
 		const session = await this.session(key);
 		const desc = VISION_MODELS[key];
 		const spec = preprocessSpec(desc.family, desc.input);
+		const dims = [
+			1,
+			3,
+			spec.height,
+			spec.width
+		];
+		let image;
+		if (isGpuImage(frame)) {
+			if (this._core.provider.device === frame.device) {
+				const buffer = this.gpuInput(key, frame.device, spec);
+				const transform$1 = FrameTensorPipeline.for(frame.device).toTensor(frame, spec, buffer);
+				return {
+					outputs: await session.run({
+						name: "input",
+						data: EMPTY_TENSOR,
+						gpuBuffer: buffer,
+						dims
+					}),
+					transform: transform$1
+				};
+			}
+			image = await readTexturePixels(frame);
+		} else image = frame;
 		const size = 3 * spec.width * spec.height;
-		let scratch = this._tensorScratch.get(key);
+		const scratchByKey = this._core.tensorScratch;
+		let scratch = scratchByKey.get(key);
 		if (!scratch || scratch.length < size) {
 			scratch = new Float32Array(size);
-			this._tensorScratch.set(key, scratch);
+			scratchByKey.set(key, scratch);
 		}
 		const { tensor, transform } = imageToTensor(image, spec, scratch);
 		return {
 			outputs: await session.run({
 				name: "input",
 				data: tensor,
-				dims: [
-					1,
-					3,
-					spec.height,
-					spec.width
-				]
+				dims
 			}),
 			transform
 		};
 	}
+	gpuInput(key, device, spec) {
+		const inputs = this._core.gpuInputs;
+		const size = FrameTensorPipeline.tensorBytes(spec);
+		const current = inputs.get(key);
+		if (current?.device === device && current.buffer.size >= size) return current.buffer;
+		current?.buffer.destroy();
+		const buffer = device.createBuffer({
+			label: `vision_input_${key}`,
+			size,
+			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+		});
+		inputs.set(key, {
+			device,
+			buffer
+		});
+		return buffer;
+	}
 	session(key) {
-		let promise = this._sessions.get(key);
+		const { sessions, store, provider } = this._core;
+		let promise = sessions.get(key);
 		if (!promise) {
-			promise = this._store.ensure(key).then((bytes) => this._provider.createSession(bytes)).catch((err) => {
-				this._sessions.delete(key);
-				this._store.evict(key);
+			promise = store.ensure(key).then((bytes) => provider.createSession(VISION_MODELS[key].family === "rtmdet-ins" ? rtmdetInsBody(bytes) : bytes)).catch((err) => {
+				sessions.delete(key);
+				store.evict(key);
 				throw err;
 			});
-			this._sessions.set(key, promise);
+			sessions.set(key, promise);
 		}
 		return promise;
 	}
 };
+const EMPTY_TENSOR = new Float32Array(0);
+/**
+* The RTMDet-Ins graph up to its head (see `RTMDET_INS_HEAD`): no NMS or
+* full-size masks in the graph, so the GPU part has fixed shapes and only
+* ~9 MB comes back. Models without those tensors run end to end.
+*/
+function rtmdetInsBody(bytes) {
+	try {
+		return extractSubgraph(bytes, Object.values(RTMDET_INS_HEAD));
+	} catch {
+		return bytes;
+	}
+}
+/** Outputs of the end2end graph: NMS done, one input-sized mask per detection. */
+function end2endPassOutputs(outputs, key) {
+	const dets = output(outputs, "dets", key);
+	const masks = output(outputs, "masks", key);
+	return {
+		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
+	};
+}
+/** Outputs of the head: selection here, mask logits only for detections asked for. */
+function headPassOutputs(outputs, key, transform) {
+	const scores = output(outputs, RTMDET_INS_HEAD.scores, key);
+	const features = output(outputs, RTMDET_INS_HEAD.maskFeatures, key);
+	const head = {
+		scores: scores.data,
+		boxes: output(outputs, RTMDET_INS_HEAD.boxes, key).data,
+		kernels: output(outputs, RTMDET_INS_HEAD.kernels, key).data,
+		maskFeatures: features.data,
+		anchors: scores.dims[1] ?? 0,
+		classes: scores.dims[2] ?? 0,
+		maskHeight: features.dims[2] ?? 0,
+		maskWidth: features.dims[3] ?? 0,
+		inputWidth: transform.inputWidth,
+		inputHeight: transform.inputHeight
+	};
+	const picked = selectInstances(head);
+	const dets = new Float32Array(picked.length * 5);
+	const labels = new Int32Array(picked.length);
+	picked.forEach(({ anchor, classIndex, score }, i) => {
+		dets.set(head.boxes.subarray(anchor * 4, anchor * 4 + 4), i * 5);
+		dets[i * 5 + 4] = score;
+		labels[i] = classIndex;
+	});
+	const planes = /* @__PURE__ */ new Map();
+	return {
+		dets,
+		labels,
+		count: picked.length,
+		maskWidth: head.maskWidth,
+		maskHeight: head.maskHeight,
+		maskLogits: true,
+		maskPlane: (index) => {
+			let plane = planes.get(index);
+			if (!plane) {
+				plane = maskLogits(head, picked[index].anchor);
+				planes.set(index, plane);
+			}
+			return plane;
+		}
+	};
+}
+/** Size plus a 64-bit hash of the pixels: equal keys mean the same picture. */
+function contentKey(image) {
+	const { data } = image;
+	const words = data.byteOffset % 4 === 0 ? data.byteLength >>> 2 : 0;
+	const view = new Uint32Array(data.buffer, data.byteOffset, words);
+	let h1 = 2166136261;
+	let h2 = 16777619 ^ data.byteLength;
+	for (let i = 0; i < words; i++) {
+		const v = view[i];
+		h1 = Math.imul(h1 ^ v, 2654435761);
+		h2 = Math.imul(h2 ^ v, 2246822519) ^ h1 >>> 15;
+	}
+	for (let i = words * 4; i < data.length; i++) h1 = Math.imul(h1 ^ data[i], 2654435761);
+	return `${image.width}x${image.height}:${(h1 >>> 0).toString(36)}:${(h2 >>> 0).toString(36)}`;
+}
 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}.`);
@@ -2034,16 +3116,16 @@ 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(pBox, isNormalized && trk.boundingBox.normalizedWidth > 0 ? {
+			const iou$1 = computeIoU(pBox, isNormalized && trk.boundingBox.normalizedWidth > 0 ? {
 				originX: trk.boundingBox.normalizedX,
 				originY: trk.boundingBox.normalizedY,
 				width: trk.boundingBox.normalizedWidth,
 				height: trk.boundingBox.normalizedHeight
 			} : trk.boundingBox);
-			if (iou >= minIoU) candidateMatches.push({
+			if (iou$1 >= minIoU) candidateMatches.push({
 				personIdx: p,
 				trackId: trk.trackId,
-				iou
+				iou: iou$1
 			});
 		}
 	}
@@ -2244,14 +3326,14 @@ var VisionBundle = class {
 				let bestIoU = .1;
 				for (const p of poseRes.people) {
 					const pBox = getPersonBoundingBox(p);
-					const iou = computeIoU(pBox, pBox.width <= 1.05 && pBox.height <= 1.05 && trk.boundingBox.normalizedWidth > 0 ? {
+					const iou$1 = computeIoU(pBox, pBox.width <= 1.05 && pBox.height <= 1.05 && trk.boundingBox.normalizedWidth > 0 ? {
 						originX: trk.boundingBox.normalizedX,
 						originY: trk.boundingBox.normalizedY,
 						width: trk.boundingBox.normalizedWidth,
 						height: trk.boundingBox.normalizedHeight
 					} : trk.boundingBox);
-					if (iou > bestIoU) {
-						bestIoU = iou;
+					if (iou$1 > bestIoU) {
+						bestIoU = iou$1;
 						bestPerson = p;
 					}
 				}
@@ -3014,7 +4096,7 @@ var VisionNode = class VisionNode$1 {
 };
 
 //#endregion
-//#region ../../nodes/node-vision/dist/renderers-ClCaeCNB.mjs
+//#region ../../nodes/node-vision/dist/renderers-CPLmY2dA.mjs
 let scratchValues = new Uint8Array(0);
 let scratchLengths = new Uint32Array(0);
 function encodeMask(mask, width, height) {
@@ -3221,7 +4303,7 @@ var MatteCompositor = class {
 		return tex;
 	}
 	/** Clears `target` and draws `picture` through `mask` into it. */
-	draw(encoder, target, picture, mask, mode, bounds) {
+	draw(encoder$1, target, picture, mask, mode, bounds) {
 		const w = mask.width;
 		const h = mask.height;
 		const data = new Float32Array(8);
@@ -3267,7 +4349,7 @@ var MatteCompositor = class {
 				}
 			]
 		});
-		const pass = encoder.beginRenderPass({
+		const pass = encoder$1.beginRenderPass({
 			label: "vision_matte_composite",
 			colorAttachments: [{
 				view: target,
@@ -3287,7 +4369,13 @@ var MatteCompositor = class {
 		pass.end();
 	}
 };
-let sharedRunner = null;
+/**
+* Runners by model options (variant, models dir, mirror), each with the runners
+* derived from it by decode options — layers that differ only in classes or
+* confidence share sessions instead of reloading the models.
+*/
+const sharedRunners = /* @__PURE__ */ new Map();
+const MAX_SHARED_RUNNERS = 4;
 let sharedSkeletonRenderer = null;
 let sharedCompositor = null;
 let sharedCompositorFormat = null;
@@ -3295,8 +4383,9 @@ let sharedCompositorFormat = null;
 const frameCache = new VisionFrameCache();
 /** The frame each node's child texture holds (drawn on its last call). */
 const heldFrameByNode = /* @__PURE__ */ new Map();
-/** Per node: a copy of the held frame, and the composited matte. */
+/** Per node: a copy of the held frame, the frame being analysed, and the composited matte. */
 const heldTextures = /* @__PURE__ */ new Map();
+const analysisTextures = /* @__PURE__ */ new Map();
 const matteTextures = /* @__PURE__ */ new Map();
 /** One tracker per vision node — track ids must not mix across nodes/sources. */
 const objectTrackers = /* @__PURE__ */ new Map();
@@ -3335,6 +4424,7 @@ function nodeTexture(textures, device, key, like, usage, label) {
 	return tex;
 }
 const heldTexture = (device, key, like) => nodeTexture(heldTextures, device, key, like, GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, "vision_held_frame");
+const analysisTexture = (device, key, like) => nodeTexture(analysisTextures, device, key, like, GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC, "vision_analysis_frame");
 const matteTexture = (device, key, like) => nodeTexture(matteTextures, device, key, like, GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC, "vision_matte");
 /** Everything that decides a frame's results besides the frame itself. */
 function cacheSource(nodeKey, child, op, width, height) {
@@ -3384,27 +4474,42 @@ function selectSubject(selected, nodeKey, frame) {
 /**
 * 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.
+* Nodes with the same model options share sessions; decode options (classes,
+* confidence, …) get a derived runner over the same sessions.
 */
 function getSharedRunner(op) {
-	const options = {
+	const modelOptions = {
 		variant: op.variant,
-		confidence: op.confidence,
-		classes: op.classes,
-		maskThreshold: op.maskThreshold,
-		featherRadius: op.featherRadius,
 		modelsDir: op.modelsDir,
 		baseUrl: op.baseUrl
 	};
-	const key = JSON.stringify(options);
-	if (sharedRunner?.key !== key) {
-		sharedRunner?.runner.close();
-		sharedRunner = {
-			key,
-			runner: VisionRunner.create(options)
+	const modelKey = JSON.stringify(modelOptions);
+	let entry = sharedRunners.get(modelKey);
+	if (!entry) {
+		if (sharedRunners.size >= MAX_SHARED_RUNNERS) {
+			const [oldestKey, oldest] = sharedRunners.entries().next().value;
+			oldest.runner.close();
+			sharedRunners.delete(oldestKey);
+		}
+		entry = {
+			runner: VisionRunner.create(modelOptions),
+			derived: /* @__PURE__ */ new Map()
 		};
+		sharedRunners.set(modelKey, entry);
+	}
+	const decodeOptions = {
+		confidence: op.confidence,
+		classes: op.classes,
+		maskThreshold: op.maskThreshold,
+		featherRadius: op.featherRadius
+	};
+	const decodeKey = JSON.stringify(decodeOptions);
+	let runner = entry.derived.get(decodeKey);
+	if (!runner) {
+		runner = entry.runner.derive(decodeOptions);
+		entry.derived.set(decodeKey, runner);
 	}
-	return sharedRunner.runner;
+	return runner;
 }
 function getObjectTracker(nodeKey, op) {
 	let tracker = objectTrackers.get(nodeKey);
@@ -3621,8 +4726,9 @@ function maskCentroid(mask) {
 	};
 }
 const VisionWebGPURenderer = async (args) => {
-	const { ctx, encoder, pass, targetView, targetWidth, targetHeight, props, drawChild } = args;
+	const { ctx, encoder: encoder$1, pass, targetView, targetWidth, targetHeight, props, drawChild } = args;
 	const { virtualMedia } = props;
+	setVisionDevice(ctx.device);
 	const rawOp = virtualMedia?.operation;
 	if (rawOp?.op !== "Vision") return;
 	const op = rawOp;
@@ -3670,11 +4776,11 @@ const VisionWebGPURenderer = async (args) => {
 	const wantsPose = op.enablePose === true || mode === "skeleton";
 	const cacheable = !wantsSelfie && !wantsPose && (wantsDetection || wantsSegmentation);
 	const source = cacheable ? cacheSource(nodeKeyStr, childMedia, op, targetWidth, targetHeight) : "";
-	const keyThresholdAt = (frame) => op.keyBackground === true ? backgroundKeyThreshold(op, compositionFrame - (frameIdx - frame), fps) : void 0;
-	const lookup = (frame) => {
-		if (!cacheable || frame === void 0) return void 0;
-		const hit = frameCache.get(source, frame);
-		if (!hit || hit.keyThreshold !== keyThresholdAt(frame)) return void 0;
+	const keyThresholdAt = (frame$1) => op.keyBackground === true ? backgroundKeyThreshold(op, compositionFrame - (frameIdx - frame$1), fps) : void 0;
+	const lookup = (frame$1) => {
+		if (!cacheable || frame$1 === void 0) return void 0;
+		const hit = frameCache.get(source, frame$1);
+		if (!hit || hit.keyThreshold !== keyThresholdAt(frame$1)) return void 0;
 		if (wantsSegmentation && visionBundle && !hit.masks) return void 0;
 		return hit;
 	};
@@ -3685,43 +4791,33 @@ const VisionWebGPURenderer = async (args) => {
 	let heldTex;
 	if (isMatteMode && hasPreviousFrame && !exact) {
 		heldTex = heldTexture(ctx.device, nodeKeyStr, childTex);
-		encoder.copyTextureToTexture({ texture: childTex }, { texture: heldTex }, [
+		encoder$1.copyTextureToTexture({ texture: childTex }, { texture: heldTex }, [
 			targetWidth,
 			targetHeight,
 			1
 		]);
 	}
+	let frame;
 	let framePixels = null;
 	if (hasPreviousFrame && !cached) {
-		const unalignedBytesPerRow = targetWidth * 4;
-		const bytesPerRow = Math.ceil(unalignedBytesPerRow / 256) * 256;
-		const bufferSize = bytesPerRow * targetHeight;
-		const stagingBuffer = ctx.device.createBuffer({
-			size: bufferSize,
-			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-			label: "vision_frame_staging"
-		});
-		const readbackEncoder = ctx.device.createCommandEncoder({ label: "vision_readback_encoder" });
-		readbackEncoder.copyTextureToBuffer({ texture: childTex }, {
-			buffer: stagingBuffer,
-			bytesPerRow,
-			rowsPerImage: targetHeight
-		}, [
+		const analysis = analysisTexture(ctx.device, nodeKeyStr, childTex);
+		const copy = ctx.device.createCommandEncoder({ label: "vision_analysis_copy" });
+		copy.copyTextureToTexture({ texture: childTex }, { texture: analysis }, [
 			targetWidth,
 			targetHeight,
 			1
 		]);
-		ctx.device.queue.submit([readbackEncoder.finish()]);
-		await stagingBuffer.mapAsync(GPUMapMode.READ);
-		const mappedBytes = new Uint8Array(stagingBuffer.getMappedRange());
-		framePixels = new Uint8ClampedArray(targetWidth * targetHeight * 4);
-		if (bytesPerRow === unalignedBytesPerRow) framePixels.set(mappedBytes.subarray(0, framePixels.length));
-		else for (let y = 0; y < targetHeight; y++) framePixels.set(mappedBytes.subarray(y * bytesPerRow, y * bytesPerRow + unalignedBytesPerRow), y * unalignedBytesPerRow);
-		stagingBuffer.unmap();
-		stagingBuffer.destroy();
+		ctx.device.queue.submit([copy.finish()]);
+		frame = {
+			texture: analysis,
+			device: ctx.device,
+			width: targetWidth,
+			height: targetHeight
+		};
+		if (isMatteMode && op.keyBackground === true) framePixels = (await readTexturePixels(frame)).data;
 	}
 	const childView = childTex.createView();
-	ctx.renderer.beginFrame(encoder, childView, {
+	ctx.renderer.beginFrame(encoder$1, childView, {
 		r: 0,
 		g: 0,
 		b: 0,
@@ -3751,13 +4847,9 @@ const VisionWebGPURenderer = async (args) => {
 				frame: frameIdx
 			});
 		}
-	} else if (framePixels) {
+	} else if (frame) {
 		const runner = getSharedRunner(op);
-		const image = {
-			data: framePixels,
-			width: targetWidth,
-			height: targetHeight
-		};
+		const image = frame;
 		let detections = [];
 		if (wantsDetection) {
 			detections = await runner.detect(image);
@@ -3784,7 +4876,7 @@ const VisionWebGPURenderer = async (args) => {
 		if (isMatteMode) {
 			subject = selectSubject(op.matteSource === "selfie" ? personMatteAsMask(personMatte) : mergeSubjectMask(frameMasks.length > 0 ? frameMasks : visionBundle?.getMaskResult(frameIdx) ?? []), nodeKeyStr, frameIdx);
 			const threshold = keyThresholdAt(heldFrame ?? frameIdx);
-			if (subject && threshold !== void 0) subject = {
+			if (subject && threshold !== void 0 && framePixels) subject = {
 				...subject,
 				mask: growMaskIntoForeground(subject.mask, subject.width, subject.height, framePixels, threshold, op.featherRadius)
 			};
@@ -3800,7 +4892,7 @@ const VisionWebGPURenderer = async (args) => {
 	if (isMatteMode) {
 		const picture = exact ? childTex : heldTex;
 		if (!subject || !picture) {
-			ctx.renderer.beginFrame(encoder, targetView, {
+			ctx.renderer.beginFrame(encoder$1, targetView, {
 				r: 0,
 				g: 0,
 				b: 0,
@@ -3814,9 +4906,9 @@ const VisionWebGPURenderer = async (args) => {
 		}
 		const maskTex = sharedCompositor.uploadMask(nodeKeyStr, subject.mask, subject.width, subject.height);
 		const matteTex = matteTexture(ctx.device, nodeKeyStr, childTex);
-		sharedCompositor.draw(encoder, matteTex.createView(), picture, maskTex, mode, mode === "crop" ? maskBounds(subject) ?? void 0 : void 0);
+		sharedCompositor.draw(encoder$1, matteTex.createView(), picture, maskTex, mode, mode === "crop" ? maskBounds(subject) ?? void 0 : void 0);
 		visionBundle?.setStencilTexture(matteTex);
-		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
+		const outPass$1 = ctx.renderer.beginFrame(encoder$1, targetView, {
 			r: 0,
 			g: 0,
 			b: 0,
@@ -3839,7 +4931,7 @@ const VisionWebGPURenderer = async (args) => {
 				width: targetWidth,
 				height: targetHeight
 			});
-			const skelPass = ctx.renderer.beginFrame(encoder, targetView, {
+			const skelPass = ctx.renderer.beginFrame(encoder$1, targetView, {
 				r: 0,
 				g: 0,
 				b: 0,
@@ -3856,7 +4948,7 @@ const VisionWebGPURenderer = async (args) => {
 		}
 	}
 	if (mode === "boxes" || mode === "tracking") {
-		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
+		const outPass$1 = ctx.renderer.beginFrame(encoder$1, targetView, {
 			r: 0,
 			g: 0,
 			b: 0,
@@ -3923,7 +5015,7 @@ const VisionWebGPURenderer = async (args) => {
 		outPass$1.end();
 		return;
 	}
-	const outPass = ctx.renderer.beginFrame(encoder, targetView, {
+	const outPass = ctx.renderer.beginFrame(encoder$1, targetView, {
 		r: 0,
 		g: 0,
 		b: 0,
@@ -3955,4 +5047,4 @@ var renderers_default = defineRenderer({ WebGPURenderer: VisionWebGPURenderer })
 
 //#endregion
 export { PoseSkeletonRenderer as a, TemporalObjectTracker as c, VisionRunner as d, analyzeSequence as f, COCO_CLASSES as h, COCO17_KEYPOINT_NAMES as i, VisionBundle as l, pinNodeToObject as m, COCO17_BONES as n, SegmentationTexturePool as o, pinNodeToLandmark as p, COCO17_KEYPOINTS as r, SpatialLandmarkTransformer as s, renderers_default as t, VisionNode as u };
-//# sourceMappingURL=renderer-mp1NN5zk.mjs.map
+//# sourceMappingURL=renderer-CqT2vxa4.mjs.map