@framefields/node-vision 2.0.2

package/dist/renderers-B24hckhO.mjs

@@ -0,0 +1,953 @@
+import { defineRenderer } from "@framefields/node-sdk/renderer";
+import { PoseSkeletonRenderer, TemporalObjectTracker, VisionRunner, maskBounds, matchPoseToTracks, mergeSubjectMask } from "@framefields/vision";
+
+//#region src/renderers/frame-cache.ts
+let scratchValues = new Uint8Array(0);
+let scratchLengths = new Uint32Array(0);
+function encodeMask(mask, width, height) {
+	if (scratchValues.length < mask.length) {
+		scratchValues = new Uint8Array(mask.length);
+		scratchLengths = new Uint32Array(mask.length);
+	}
+	const values = scratchValues;
+	const lengths = scratchLengths;
+	let runs = 0;
+	let start = 0;
+	for (let i = 1; i <= mask.length; i++) if (i === mask.length || mask[i] !== mask[start]) {
+		values[runs] = mask[start];
+		lengths[runs] = i - start;
+		runs++;
+		start = i;
+	}
+	return {
+		width,
+		height,
+		values: values.slice(0, runs),
+		lengths: lengths.slice(0, runs)
+	};
+}
+function decodeMask(rle) {
+	const out = new Uint8Array(rle.width * rle.height);
+	let at = 0;
+	for (let r = 0; r < rle.values.length; r++) {
+		const end = at + rle.lengths[r];
+		if (rle.values[r] !== 0) out.fill(rle.values[r], at, end);
+		at = end;
+	}
+	return out;
+}
+function rleBytes(rle) {
+	return rle.values.byteLength + rle.lengths.byteLength;
+}
+function toCachedMask(mask) {
+	const { mask: data, ...rest } = mask;
+	return {
+		...rest,
+		rle: encodeMask(data, mask.width, mask.height)
+	};
+}
+function fromCachedMask(mask) {
+	const { rle, ...rest } = mask;
+	return {
+		...rest,
+		mask: decodeMask(rle)
+	};
+}
+function resultBytes(result) {
+	let bytes = 512 + result.detections.length * 128 + result.objects.length * 256;
+	for (const m of result.masks ?? []) bytes += rleBytes(m.rle);
+	if (result.subject) bytes += rleBytes(result.subject.mask.rle);
+	return bytes;
+}
+/** Results by source (node + inference settings) and frame, least recently used out first. */
+var VisionFrameCache = class {
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	constructor(maxBytes = 256 * 1024 * 1024) {
+		this.maxBytes = maxBytes;
+	}
+	get(source, frame) {
+		const key = `${source}#${frame}`;
+		const hit = this.entries.get(key);
+		if (hit) {
+			this.entries.delete(key);
+			this.entries.set(key, hit);
+		}
+		return hit;
+	}
+	set(source, frame, result) {
+		const key = `${source}#${frame}`;
+		const old = this.entries.get(key);
+		if (old) {
+			this.bytes -= resultBytes(old);
+			this.entries.delete(key);
+		}
+		this.entries.set(key, result);
+		this.bytes += resultBytes(result);
+		for (const [k, v] of this.entries) {
+			if (this.bytes <= this.maxBytes) break;
+			this.entries.delete(k);
+			this.bytes -= resultBytes(v);
+		}
+	}
+	clear() {
+		this.entries.clear();
+		this.bytes = 0;
+	}
+	get size() {
+		return this.entries.size;
+	}
+};
+
+//#endregion
+//#region src/renderers/matte-compositor.ts
+/**
+* GPU composite for the mask-family modes: the picture times the subject mask,
+* in one full-screen pass. Replaces building the RGBA result on the CPU and
+* uploading it; only the 8-bit mask goes to the GPU.
+*
+*  - matte: picture × mask (premultiplied, so the background is transparent)
+*  - mask:  white silhouette (rgb = mask, a = 1)
+*  - crop:  matte, with the subject's bounding box stretched to the frame
+*/
+const WGSL = `
+struct Params {
+	mode: u32,          // 0 matte, 1 mask, 2 crop
+	_pad: u32,
+	cropMin: vec2<f32>, // uv of the subject bounds (crop)
+	cropMax: vec2<f32>,
+	_pad2: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var picture: texture_2d<f32>;
+@group(0) @binding(2) var mask: texture_2d<f32>;
+@group(0) @binding(3) var samp: sampler;
+
+struct VSOut {
+	@builtin(position) pos: vec4<f32>,
+	@location(0) uv: vec2<f32>,
+};
+
+@vertex fn vs(@builtin(vertex_index) i: u32) -> VSOut {
+	var p = array<vec2<f32>, 3>(vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
+	var out: VSOut;
+	out.pos = vec4(p[i], 0.0, 1.0);
+	out.uv = vec2(p[i].x * 0.5 + 0.5, 0.5 - p[i].y * 0.5);
+	return out;
+}
+
+@fragment fn fs(in: VSOut) -> @location(0) vec4<f32> {
+	var uv = in.uv;
+	if (params.mode == 2u) {
+		uv = mix(params.cropMin, params.cropMax, uv);
+	}
+	let m = textureSampleLevel(mask, samp, uv, 0.0).r;
+	if (params.mode == 1u) {
+		return vec4(m, m, m, 1.0);
+	}
+	return textureSampleLevel(picture, samp, uv, 0.0) * m;
+}
+`;
+var MatteCompositor = class {
+	pipeline;
+	sampler;
+	uniforms = [];
+	uniformIndex = 0;
+	/** One 8-bit mask texture per node, rewritten each frame. */
+	masks = /* @__PURE__ */ new Map();
+	constructor(device, format) {
+		this.device = device;
+		const module = device.createShaderModule({
+			label: "vision_matte_composite",
+			code: WGSL
+		});
+		this.pipeline = device.createRenderPipeline({
+			label: "vision_matte_composite",
+			layout: "auto",
+			vertex: {
+				module,
+				entryPoint: "vs"
+			},
+			fragment: {
+				module,
+				entryPoint: "fs",
+				targets: [{ format }]
+			},
+			primitive: { topology: "triangle-list" }
+		});
+		this.sampler = device.createSampler({
+			magFilter: "linear",
+			minFilter: "linear"
+		});
+	}
+	/** Uploads a frame-sized 0..255 mask for `key` and returns its texture. */
+	uploadMask(key, mask, width, height) {
+		let tex = this.masks.get(key);
+		if (!tex || tex.width !== width || tex.height !== height) {
+			tex?.destroy();
+			tex = this.device.createTexture({
+				label: `vision_mask_${key}`,
+				size: [width, height],
+				format: "r8unorm",
+				usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+			});
+			this.masks.set(key, tex);
+		}
+		const aligned = Math.ceil(width / 256) * 256;
+		let bytes = mask;
+		if (aligned !== width) {
+			bytes = new Uint8Array(aligned * height);
+			for (let y = 0; y < height; y++) bytes.set(mask.subarray(y * width, (y + 1) * width), y * aligned);
+		}
+		this.device.queue.writeTexture({ texture: tex }, bytes.buffer, {
+			offset: bytes.byteOffset,
+			bytesPerRow: aligned,
+			rowsPerImage: height
+		}, {
+			width,
+			height
+		});
+		return tex;
+	}
+	/** Clears `target` and draws `picture` through `mask` into it. */
+	draw(encoder, target, picture, mask, mode, bounds) {
+		const w = mask.width;
+		const h = mask.height;
+		const data = new Float32Array(8);
+		const view = new Uint32Array(data.buffer);
+		view[0] = mode === "matte" ? 0 : mode === "mask" ? 1 : 2;
+		if (mode === "crop" && bounds) {
+			data[2] = bounds.x0 / w;
+			data[3] = bounds.y0 / h;
+			data[4] = (bounds.x1 + 1) / w;
+			data[5] = (bounds.y1 + 1) / h;
+		} else {
+			data[2] = 0;
+			data[3] = 0;
+			data[4] = 1;
+			data[5] = 1;
+			if (mode === "crop") view[0] = 0;
+		}
+		if (this.uniformIndex >= this.uniforms.length) this.uniforms.push(this.device.createBuffer({
+			size: data.byteLength,
+			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+		}));
+		const uniform = this.uniforms[this.uniformIndex];
+		this.uniformIndex = (this.uniformIndex + 1) % 16;
+		this.device.queue.writeBuffer(uniform, 0, data);
+		const bindGroup = this.device.createBindGroup({
+			layout: this.pipeline.getBindGroupLayout(0),
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: uniform }
+				},
+				{
+					binding: 1,
+					resource: picture.createView()
+				},
+				{
+					binding: 2,
+					resource: mask.createView()
+				},
+				{
+					binding: 3,
+					resource: this.sampler
+				}
+			]
+		});
+		const pass = encoder.beginRenderPass({
+			label: "vision_matte_composite",
+			colorAttachments: [{
+				view: target,
+				loadOp: "clear",
+				storeOp: "store",
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				}
+			}]
+		});
+		pass.setPipeline(this.pipeline);
+		pass.setBindGroup(0, bindGroup);
+		pass.draw(3);
+		pass.end();
+	}
+};
+
+//#endregion
+//#region src/renderers/webgpu-renderer.ts
+let sharedRunner = null;
+let sharedSkeletonRenderer = null;
+let sharedCompositor = null;
+let sharedCompositorFormat = null;
+/** Analysed frames, shared by every vision node in the process. */
+const frameCache = new VisionFrameCache();
+/** The frame each node's child texture holds (drawn on its last call). */
+const heldFrameByNode = /* @__PURE__ */ new Map();
+/** Per node: a copy of the held frame, and the composited matte. */
+const heldTextures = /* @__PURE__ */ new Map();
+const matteTextures = /* @__PURE__ */ new Map();
+/** One tracker per vision node — track ids must not mix across nodes/sources. */
+const objectTrackers = /* @__PURE__ */ new Map();
+/**
+* Persistent per-node child textures. The shared frame encoder is submitted at
+* the END of the frame, so a node renderer cannot read back the child it just
+* drew. We keep the texture around and read back the PREVIOUS frame's pixels at
+* the start of the next call — a stable one-frame delay instead of the
+* unpredictable multi-frame lag you get from pooled textures.
+*
+* Keyed on the stable Vision `Effect` instance (render ids change every frame),
+* with a size-keyed fallback for raw operation nodes.
+*/
+const childTexturesByEffect = /* @__PURE__ */ new WeakMap();
+const childTexturesByKey = /* @__PURE__ */ new Map();
+/**
+* Last successful subject mask, reused for a few frames when the model misses —
+* a transient miss then holds the silhouette instead of flashing the raw plate.
+* Keyed per node/effect so multiple vision nodes do not collide.
+*/
+const lastSubjectByNode = /* @__PURE__ */ new Map();
+const SUBJECT_HOLD_FRAMES = 3;
+/** A per-node texture shaped like `like`, recreated when the size changes. */
+function nodeTexture(textures, device, key, like, usage, label) {
+	let tex = textures.get(key);
+	if (!tex || tex.width !== like.width || tex.height !== like.height || tex.format !== like.format) {
+		tex?.destroy();
+		tex = device.createTexture({
+			size: [like.width, like.height],
+			format: like.format,
+			usage,
+			label
+		});
+		textures.set(key, tex);
+	}
+	return tex;
+}
+const heldTexture = (device, key, like) => nodeTexture(heldTextures, device, key, like, GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, "vision_held_frame");
+const matteTexture = (device, key, like) => nodeTexture(matteTextures, device, key, like, GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC, "vision_matte");
+/** Everything that decides a frame's results besides the frame itself. */
+function cacheSource(nodeKey, child, op, width, height) {
+	const c = child;
+	return JSON.stringify([
+		nodeKey,
+		c?.operation?.id ?? c?.id ?? null,
+		width,
+		height,
+		op.mode ?? "passthrough",
+		op.variant,
+		op.confidence,
+		op.classes,
+		op.maskThreshold,
+		op.featherRadius,
+		op.matteSource,
+		op.keyBackground === true,
+		op.maxMissedFrames
+	]);
+}
+/** The background-key threshold at `frame` (it may be animated). */
+function backgroundKeyThreshold(op, frame, fps) {
+	const raw = op.backgroundKeyThreshold;
+	if (typeof raw === "number") return raw;
+	if (typeof raw?.get === "function") return Number(raw.get({
+		frame,
+		fps
+	}));
+	if (typeof raw?._value === "number") return Number(raw._value);
+	return 70;
+}
+/**
+* The model's subject, or the last one through brief misses: a transient miss
+* then holds the silhouette instead of flashing the raw plate.
+*/
+function selectSubject(selected, nodeKey, frame) {
+	if (selected) {
+		lastSubjectByNode.set(nodeKey, {
+			mask: selected,
+			frame
+		});
+		return selected;
+	}
+	const last = lastSubjectByNode.get(nodeKey);
+	if (last && frame - last.frame <= SUBJECT_HOLD_FRAMES) return last.mask;
+}
+/**
+* Lazy shared runner — `create()` is a pure constructor (zero I/O); the first frame that
+* requests a task triggers that task's model download at inference time (never at init).
+* Recreated only when an option that changes inference changes.
+*/
+function getSharedRunner(op) {
+	const options = {
+		variant: op.variant,
+		confidence: op.confidence,
+		classes: op.classes,
+		maskThreshold: op.maskThreshold,
+		featherRadius: op.featherRadius,
+		modelsDir: op.modelsDir,
+		baseUrl: op.baseUrl
+	};
+	const key = JSON.stringify(options);
+	if (sharedRunner?.key !== key) {
+		sharedRunner?.runner.close();
+		sharedRunner = {
+			key,
+			runner: VisionRunner.create(options)
+		};
+	}
+	return sharedRunner.runner;
+}
+function getObjectTracker(nodeKey, op) {
+	let tracker = objectTrackers.get(nodeKey);
+	if (!tracker) {
+		tracker = new TemporalObjectTracker({ maxMissedFrames: op.maxMissedFrames ?? 15 });
+		objectTrackers.set(nodeKey, tracker);
+	}
+	return tracker;
+}
+/**
+* Normalizes the runner's pose keypoints (plate pixel space) to [0, 1] landmarks, which is
+* the contract the signal bundle and the skeleton pipeline expect.
+*/
+function normalizePoseKeypoints(result, width, height) {
+	if (width <= 0 || height <= 0) return result;
+	return { people: result.people.map((person) => ({
+		...person,
+		keypoints: person.keypoints.map((k) => ({
+			x: k.x / width,
+			y: k.y / height,
+			visibility: k.visibility
+		}))
+	})) };
+}
+/** Assigns each decoded instance mask to the temporal track whose box center is nearest the mask's centroid. */
+function assignMasksToTracks(masks, tracked) {
+	return masks.map((mask) => {
+		const { cx, cy } = maskCentroid(mask);
+		let best = null;
+		for (const obj of tracked) {
+			const dx = obj.centerX - cx;
+			const dy = obj.centerY - cy;
+			const distance = dx * dx + dy * dy;
+			if (!best || distance < best.distance) best = {
+				trackId: obj.trackId,
+				distance
+			};
+		}
+		return best ? {
+			...mask,
+			trackId: best.trackId
+		} : mask;
+	});
+}
+/**
+* Grows a subject mask into connected foreground pixels — seeding a flood fill
+* from the subject through pixels that differ from the sampled backdrop recovers
+* thin or fast-moving edges (hair, fabric) without adding a near-uniform studio
+* wall or its soft grey shadow.
+*/
+function fillInternalHoles(mask, width, height) {
+	const n = width * height;
+	const exterior = new Uint8Array(n);
+	const queue = new Int32Array(n);
+	let tail = 0;
+	const seed = (i) => {
+		if (exterior[i] || mask[i] > 0) return;
+		exterior[i] = 1;
+		queue[tail++] = i;
+	};
+	for (let x = 0; x < width; x++) {
+		seed(x);
+		seed((height - 1) * width + x);
+	}
+	for (let y = 0; y < height; y++) {
+		seed(y * width);
+		seed(y * width + width - 1);
+	}
+	let head = 0;
+	while (head < tail) {
+		const i = queue[head++];
+		const x = i % width;
+		let j = i + 1;
+		if (x + 1 < width && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+		j = i - 1;
+		if (x > 0 && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+		j = i + width;
+		if (j < n && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+		j = i - width;
+		if (j >= 0 && !exterior[j] && mask[j] === 0) {
+			exterior[j] = 1;
+			queue[tail++] = j;
+		}
+	}
+	for (let i = 0; i < n; i++) if (mask[i] === 0 && exterior[i] === 0) mask[i] = 255;
+}
+function smoothMaskBoundary(mask, width, height, radius = 2) {
+	if (radius <= 0) return mask;
+	const temp = new Uint8Array(width * height);
+	const out = new Uint8Array(width * height);
+	const div = 2 * radius + 1;
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		let sum = 0;
+		for (let k = -radius; k <= radius; k++) {
+			const x = Math.max(0, Math.min(width - 1, k));
+			sum += mask[row + x];
+		}
+		for (let x = 0; x < width; x++) {
+			temp[row + x] = Math.round(sum / div);
+			const xOut = Math.max(0, x - radius);
+			const xIn = Math.min(width - 1, x + radius + 1);
+			sum += mask[row + xIn] - mask[row + xOut];
+		}
+	}
+	const sums = new Float64Array(width);
+	for (let k = -radius; k <= radius; k++) {
+		const row = Math.max(0, Math.min(height - 1, k)) * width;
+		for (let x = 0; x < width; x++) sums[x] += temp[row + x];
+	}
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		const rowOut = Math.max(0, y - radius) * width;
+		const rowIn = Math.min(height - 1, y + radius + 1) * width;
+		for (let x = 0; x < width; x++) {
+			out[row + x] = Math.round(sums[x] / div);
+			sums[x] += temp[rowIn + x] - temp[rowOut + x];
+		}
+	}
+	return out;
+}
+function growMaskIntoForeground(mask, width, height, pixels, threshold, featherRadius) {
+	let br = 0;
+	let bg = 0;
+	let bb = 0;
+	let count = 0;
+	const sample = (x, y) => {
+		const i = y * width + x;
+		if (mask[i]) return;
+		const p = i * 4;
+		br += pixels[p];
+		bg += pixels[p + 1];
+		bb += pixels[p + 2];
+		count++;
+	};
+	for (let x = 0; x < width; x += 4) {
+		sample(x, 0);
+		sample(x, height - 1);
+	}
+	for (let y = 0; y < height; y += 4) {
+		sample(0, y);
+		sample(width - 1, y);
+	}
+	if (count === 0) return mask;
+	br /= count;
+	bg /= count;
+	bb /= count;
+	const n = width * height;
+	const fg = new Uint8Array(n);
+	for (let i = 0, p = 0; i < n; i++, p += 4) fg[i] = Math.max(Math.abs(pixels[p] - br), Math.abs(pixels[p + 1] - bg), Math.abs(pixels[p + 2] - bb)) > threshold ? 1 : 0;
+	const queue = new Int32Array(n);
+	let tail = 0;
+	for (let i = 0; i < n; i++) if (mask[i] > 0) {
+		if (fg[i]) mask[i] = 255;
+		queue[tail++] = i;
+	}
+	let head = 0;
+	while (head < tail) {
+		const i = queue[head++];
+		const x = i % width;
+		let j = i + 1;
+		if (x + 1 < width && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+		j = i - 1;
+		if (x > 0 && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+		j = i + width;
+		if (j < n && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+		j = i - width;
+		if (j >= 0 && mask[j] !== 255 && fg[j]) {
+			mask[j] = 255;
+			queue[tail++] = j;
+		}
+	}
+	fillInternalHoles(mask, width, height);
+	return smoothMaskBoundary(mask, width, height, featherRadius !== void 0 && featherRadius > 0 ? Math.max(1, Math.min(8, Math.round(featherRadius * 50))) : 2);
+}
+function maskCentroid(mask) {
+	const { mask: data, width, height } = mask;
+	let sumX = 0;
+	let sumY = 0;
+	let count = 0;
+	for (let y = 0; y < height; y++) {
+		const row = y * width;
+		for (let x = 0; x < width; x++) if (data[row + x] > 0) {
+			sumX += x;
+			sumY += y;
+			count++;
+		}
+	}
+	if (count === 0) return {
+		cx: 0,
+		cy: 0
+	};
+	return {
+		cx: sumX / count,
+		cy: sumY / count
+	};
+}
+const VisionWebGPURenderer = async (args) => {
+	const { ctx, encoder, pass, targetView, targetWidth, targetHeight, props, drawChild } = args;
+	const { virtualMedia } = props;
+	const rawOp = virtualMedia?.operation;
+	if (rawOp?.op !== "Vision") return;
+	const op = rawOp;
+	pass.end();
+	const childMedia = virtualMedia?.children?.[0];
+	if (!childMedia) return;
+	const effectKey = op.effect;
+	const hasEffectKey = effectKey !== void 0 && effectKey !== null;
+	const nodeKeyStr = virtualMedia?.id ?? rawOp?.id ?? `${targetWidth}x${targetHeight}_${op.mode}_${op.variant}_${op.keyBackground}_${op.backgroundKeyThreshold}`;
+	const fallbackKey = `vision-${nodeKeyStr}`;
+	let childTex = hasEffectKey ? childTexturesByEffect.get(effectKey) : childTexturesByKey.get(fallbackKey);
+	if (childTex && (childTex.width !== targetWidth || childTex.height !== targetHeight)) {
+		childTex.destroy();
+		childTex = void 0;
+		if (hasEffectKey) childTexturesByEffect.delete(effectKey);
+		else childTexturesByKey.delete(fallbackKey);
+	}
+	const hasPreviousFrame = childTex !== void 0;
+	if (!childTex) {
+		childTex = ctx.device.createTexture({
+			size: [targetWidth, targetHeight],
+			format: ctx.renderer.format,
+			usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
+			label: "vision_child_persistent"
+		});
+		if (hasEffectKey) childTexturesByEffect.set(effectKey, childTex);
+		else childTexturesByKey.set(fallbackKey, childTex);
+		if (childTexturesByKey.size > 4) {
+			const oldest = childTexturesByKey.keys().next().value;
+			if (oldest && oldest !== fallbackKey) {
+				childTexturesByKey.get(oldest)?.destroy();
+				childTexturesByKey.delete(oldest);
+			}
+		}
+	}
+	const frameIdx = props.frame ?? 0;
+	const fps = props.fps ?? 24;
+	const mode = op.mode ?? "passthrough";
+	const isMatteMode = mode === "mask" || mode === "matte" || mode === "crop";
+	const visionBundle = op.visionBundle ?? virtualMedia.visionBundle;
+	const wantsDetection = op.enableDetection !== false || mode === "boxes" || mode === "tracking";
+	const wantsSegmentation = op.enableSegmentation === true || isMatteMode && op.matteSource !== "selfie";
+	const wantsSelfie = op.enableMatte === true || isMatteMode && op.matteSource === "selfie";
+	const wantsPose = op.enablePose === true || mode === "skeleton";
+	const cacheable = !wantsSelfie && !wantsPose && (wantsDetection || wantsSegmentation);
+	const source = cacheable ? cacheSource(nodeKeyStr, childMedia, op, targetWidth, targetHeight) : "";
+	const keyThresholdAt = (frame) => op.keyBackground === true ? backgroundKeyThreshold(op, frame, fps) : void 0;
+	const lookup = (frame) => {
+		if (!cacheable || frame === void 0) return void 0;
+		const hit = frameCache.get(source, frame);
+		if (!hit || hit.keyThreshold !== keyThresholdAt(frame)) return void 0;
+		if (wantsSegmentation && visionBundle && !hit.masks) return void 0;
+		return hit;
+	};
+	const heldFrame = hasPreviousFrame ? heldFrameByNode.get(nodeKeyStr) : void 0;
+	let cached = lookup(frameIdx);
+	const exact = cached !== void 0;
+	if (!cached) cached = lookup(heldFrame);
+	let heldTex;
+	if (isMatteMode && hasPreviousFrame && !exact) {
+		heldTex = heldTexture(ctx.device, nodeKeyStr, childTex);
+		encoder.copyTextureToTexture({ texture: childTex }, { texture: heldTex }, [
+			targetWidth,
+			targetHeight,
+			1
+		]);
+	}
+	let framePixels = null;
+	if (hasPreviousFrame && !cached) {
+		const unalignedBytesPerRow = targetWidth * 4;
+		const bytesPerRow = Math.ceil(unalignedBytesPerRow / 256) * 256;
+		const bufferSize = bytesPerRow * targetHeight;
+		const stagingBuffer = ctx.device.createBuffer({
+			size: bufferSize,
+			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+			label: "vision_frame_staging"
+		});
+		const readbackEncoder = ctx.device.createCommandEncoder({ label: "vision_readback_encoder" });
+		readbackEncoder.copyTextureToBuffer({ texture: childTex }, {
+			buffer: stagingBuffer,
+			bytesPerRow,
+			rowsPerImage: targetHeight
+		}, [
+			targetWidth,
+			targetHeight,
+			1
+		]);
+		ctx.device.queue.submit([readbackEncoder.finish()]);
+		await stagingBuffer.mapAsync(GPUMapMode.READ);
+		const mappedBytes = new Uint8Array(stagingBuffer.getMappedRange());
+		framePixels = new Uint8ClampedArray(targetWidth * targetHeight * 4);
+		if (bytesPerRow === unalignedBytesPerRow) framePixels.set(mappedBytes.subarray(0, framePixels.length));
+		else for (let y = 0; y < targetHeight; y++) framePixels.set(mappedBytes.subarray(y * bytesPerRow, y * bytesPerRow + unalignedBytesPerRow), y * unalignedBytesPerRow);
+		stagingBuffer.unmap();
+		stagingBuffer.destroy();
+	}
+	const childView = childTex.createView();
+	ctx.renderer.beginFrame(encoder, childView, {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 0
+	}, targetWidth, targetHeight, "clear").end();
+	await drawChild(childMedia, { ...props }, childView, childTex, targetWidth, targetHeight);
+	heldFrameByNode.set(nodeKeyStr, frameIdx);
+	let frameObjects = [];
+	let frameMasks = [];
+	let personMatte;
+	let currentPoseRes;
+	let subject;
+	if (cached) {
+		frameObjects = cached.objects;
+		if (wantsDetection) visionBundle?.setObjectResult(frameIdx, {
+			objects: cached.objects,
+			rawDetections: cached.detections
+		});
+		if (wantsSegmentation && visionBundle && cached.masks) {
+			frameMasks = cached.masks.map(fromCachedMask);
+			visionBundle.setMaskResult(frameIdx, frameMasks);
+		}
+		if (cached.subject) {
+			subject = fromCachedMask(cached.subject.mask);
+			lastSubjectByNode.set(nodeKeyStr, {
+				mask: subject,
+				frame: frameIdx
+			});
+		}
+	} else if (framePixels) {
+		const runner = getSharedRunner(op);
+		const image = {
+			data: framePixels,
+			width: targetWidth,
+			height: targetHeight
+		};
+		let detections = [];
+		if (wantsDetection) {
+			detections = await runner.detect(image);
+			const tracker = getObjectTracker(nodeKeyStr, op);
+			if (frameIdx === 0) tracker.reset();
+			frameObjects = tracker.update(detections, frameIdx, fps);
+			visionBundle?.setObjectResult(frameIdx, {
+				objects: frameObjects,
+				rawDetections: detections
+			});
+		}
+		if (wantsSegmentation) {
+			frameMasks = assignMasksToTracks((await runner.segment(image)).masks, frameObjects);
+			visionBundle?.setMaskResult(frameIdx, frameMasks);
+		}
+		if (wantsSelfie) {
+			personMatte = await runner.matte(image);
+			visionBundle?.setMatteResult(frameIdx, personMatte);
+		}
+		if (wantsPose) {
+			currentPoseRes = { people: matchPoseToTracks(normalizePoseKeypoints(await runner.pose(image), image.width, image.height).people, frameObjects) };
+			visionBundle?.setPoseResult(frameIdx, currentPoseRes);
+		}
+		if (isMatteMode) {
+			subject = selectSubject(op.matteSource === "selfie" ? personMatteAsMask(personMatte) : mergeSubjectMask(frameMasks.length > 0 ? frameMasks : visionBundle?.getMaskResult(frameIdx) ?? []), nodeKeyStr, frameIdx);
+			const threshold = keyThresholdAt(heldFrame ?? frameIdx);
+			if (subject && threshold !== void 0) subject = {
+				...subject,
+				mask: growMaskIntoForeground(subject.mask, subject.width, subject.height, framePixels, threshold, op.featherRadius)
+			};
+		}
+		if (cacheable && heldFrame !== void 0) frameCache.set(source, heldFrame, {
+			detections,
+			objects: frameObjects,
+			masks: visionBundle ? frameMasks.map(toCachedMask) : null,
+			subject: subject ? { mask: toCachedMask(subject) } : null,
+			keyThreshold: keyThresholdAt(heldFrame)
+		});
+	}
+	if (isMatteMode) {
+		const picture = exact ? childTex : heldTex;
+		if (!subject || !picture) {
+			ctx.renderer.beginFrame(encoder, targetView, {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 0
+			}, targetWidth, targetHeight, "clear").end();
+			return;
+		}
+		if (!sharedCompositor || sharedCompositorFormat !== ctx.renderer.format) {
+			sharedCompositor = new MatteCompositor(ctx.device, ctx.renderer.format);
+			sharedCompositorFormat = ctx.renderer.format;
+		}
+		const maskTex = sharedCompositor.uploadMask(nodeKeyStr, subject.mask, subject.width, subject.height);
+		const matteTex = matteTexture(ctx.device, nodeKeyStr, childTex);
+		sharedCompositor.draw(encoder, matteTex.createView(), picture, maskTex, mode, mode === "crop" ? maskBounds(subject) ?? void 0 : void 0);
+		visionBundle?.setStencilTexture(matteTex);
+		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "clear");
+		ctx.renderer.drawTexture(outPass$1, matteTex, {
+			x: 0,
+			y: 0,
+			width: targetWidth,
+			height: targetHeight
+		});
+		outPass$1.end();
+		return;
+	}
+	if (mode === "skeleton") {
+		if (!sharedSkeletonRenderer) sharedSkeletonRenderer = new PoseSkeletonRenderer(ctx.device);
+		const person = (visionBundle?.getPoseResult(frameIdx) ?? currentPoseRes)?.people[0];
+		if (person && person.keypoints.length > 0) {
+			const skelTex = sharedSkeletonRenderer.renderToTexture(person.keypoints, {
+				width: targetWidth,
+				height: targetHeight
+			});
+			const skelPass = ctx.renderer.beginFrame(encoder, targetView, {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 0
+			}, targetWidth, targetHeight, "clear");
+			ctx.renderer.drawTexture(skelPass, skelTex, {
+				x: 0,
+				y: 0,
+				width: targetWidth,
+				height: targetHeight
+			});
+			skelPass.end();
+			return;
+		}
+	}
+	if (mode === "boxes" || mode === "tracking") {
+		const outPass$1 = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "clear");
+		ctx.renderer.drawTexture(outPass$1, childTex, {
+			x: 0,
+			y: 0,
+			width: targetWidth,
+			height: targetHeight
+		});
+		const objects = frameObjects.length > 0 ? frameObjects : visionBundle?.getObjectResult(frameIdx).objects ?? [];
+		if (objects.length > 0) {
+			const boxColor = "#38bdf8";
+			const stroke = 2;
+			for (const obj of objects) {
+				if (!obj.active) continue;
+				const b = obj.boundingBox;
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: b.width,
+					height: stroke
+				}, boxColor);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY + b.height - stroke,
+					width: b.width,
+					height: stroke
+				}, boxColor);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: stroke,
+					height: b.height
+				}, boxColor);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX + b.width - stroke,
+					y: b.originY,
+					width: stroke,
+					height: b.height
+				}, boxColor);
+				const cornerLen = Math.min(16, b.width / 4, b.height / 4);
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: cornerLen,
+					height: stroke * 2
+				}, "#ffffff");
+				ctx.renderer.drawRect(outPass$1, {
+					x: b.originX,
+					y: b.originY,
+					width: stroke * 2,
+					height: cornerLen
+				}, "#ffffff");
+				if (mode === "tracking") ctx.renderer.drawRect(outPass$1, {
+					x: obj.centerX - 3,
+					y: obj.centerY - 3,
+					width: 6,
+					height: 6
+				}, "#ef4444", 3);
+			}
+		}
+		outPass$1.end();
+		return;
+	}
+	const outPass = ctx.renderer.beginFrame(encoder, targetView, {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 0
+	}, targetWidth, targetHeight, "clear");
+	ctx.renderer.drawTexture(outPass, childTex, {
+		x: 0,
+		y: 0,
+		width: targetWidth,
+		height: targetHeight
+	});
+	outPass.end();
+};
+/** Adapts a Selfie Segmenter matte to the instance-mask shape the composite path takes. */
+function personMatteAsMask(matte) {
+	if (!matte || matte.coverage <= 0) return void 0;
+	const area = Math.round(matte.coverage * matte.width * matte.height);
+	return {
+		category: "person",
+		mask: matte.mask,
+		width: matte.width,
+		height: matte.height,
+		area,
+		coverage: matte.coverage,
+		detectionIndex: -1
+	};
+}
+
+//#endregion
+//#region src/renderers/index.ts
+var renderers_default = defineRenderer({ WebGPURenderer: VisionWebGPURenderer });
+
+//#endregion
+export { renderers_default as t };
+//# sourceMappingURL=renderers-B24hckhO.mjs.map