framefields 2.9.2 → 2.10.0-canary.0

package/dist/{renderer-B2P1vgb7.mjs → src-BU6vm9sP-DFJ3phW0.mjs}

@@ -1,19 +1,19 @@
-import { Pt as frameSignal, pn as programmaticSignal } from "./dist-BlIrsfcn.mjs";
-import { n as defineRenderer } from "./renderer-mNSyac1V.mjs";
-import { a as PoseSkeletonComputePipeline } from "./dist-Buaaj-Ul.mjs";
+import { Pt as frameSignal, pn as programmaticSignal } from "./dist-Bf2_efYP.mjs";
+import { a as PoseSkeletonComputePipeline } from "./dist-BIE8fvlv.mjs";
 import { existsSync, mkdirSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 
-//#region ../vision/dist/registry-RNCQoD9e.mjs
+//#region ../vision/dist/registry-DOHiTjt1.mjs
 const hf = (repo, revision, path$1) => `https://huggingface.co/${repo}/resolve/${revision}/${path$1}`;
 const RTMDET_INS_REPO = "tori29umai/rtmdet-ins-onnx-person-masks";
 const RTMDET_INS_REV = "e5218e8d47d7c50077f27f9893a28e0ef2ad5656";
 const RTMDET_INS_SOURCE = "RTMDet-Ins (OpenMMLab mmdetection, Apache-2.0), mmdeploy ONNX export";
 const RTMO_SOURCE = "RTMO (OpenMMLab mmpose, Apache-2.0), ONNX export";
 const SELFIE_SOURCE = "MediaPipe Selfie Segmenter (Google, Apache-2.0), ONNX export";
+const DEPTH_SOURCE = "Depth Anything V2 Small (TikTok / HKU, Apache-2.0), ONNX export";
 const models = {
 	"rtmdet-ins-t": {
 		key: "rtmdet-ins-t",
@@ -94,9 +94,23 @@ const models = {
 		sha256: "7a0adcfdb1715d3b0ff0f61486d8a181c33f4a208343a5abfccbc6540e872d24",
 		input: [256, 144],
 		source: SELFIE_SOURCE
+	},
+	"depth-anything-v2-s": {
+		key: "depth-anything-v2-s",
+		family: "depth-anything",
+		filename: "depth-anything-v2-s.onnx",
+		url: hf("onnx-community/depth-anything-v2-small", "4472b7362082ad9968fee890ca0f1e5aca36b93d", "onnx/model.onnx"),
+		bytes: 99060839,
+		sha256: "afb6a5c28f3b6bf1618c6e43f02073ef9dfdc70e937502d51603e57b0a1df10c",
+		input: [518, 518],
+		source: DEPTH_SOURCE
 	}
 };
 const VISION_MODELS = models;
+/** Adds a pinned model from a separately licensed package to the registry. */
+function registerVisionModel(descriptor) {
+	models[descriptor.key] = descriptor;
+}
 /**
 * Resolves the model for a task. `detect` and `segment` share RTMDet-Ins (one forward pass
 * yields both); `matte` picks the landscape Selfie Segmenter for wide frames.
@@ -191,7 +205,7 @@ const COCO_CLASSES = [
 ];
 
 //#endregion
-//#region ../vision/dist/src-Bnr8DUC-.mjs
+//#region ../vision/dist/src-BU6vm9sP.mjs
 function computeIoU(boxA, boxB) {
 	const xA = Math.max(boxA.originX, boxB.originX);
 	const yA = Math.max(boxA.originY, boxB.originY);
@@ -663,6 +677,35 @@ async function analyzeSequence(frames, options) {
 		masks
 	};
 }
+/** Model input size for a frame: the short side at `short`, the other kept to the frame's aspect, both multiples of the 14 px ViT patch. */
+function depthInputSize(width, height, short) {
+	const snap = (v) => Math.max(14, Math.round(v / 14) * 14);
+	return width >= height ? [snap(short * width / height), snap(short)] : [snap(short), snap(short * height / width)];
+}
+/** Share of samples clipped at each end, so a stray hot pixel does not set the range. */
+const TAIL = .01;
+/**
+* Depth Anything decode: `predicted_depth [1, h, w]` relative inverse depth →
+* 0 (farthest) … 1 (nearest), at the model's resolution. The range is the
+* frame's 1st…99th percentile, so it is relative to the frame, not metric.
+*/
+function decodeDepth(predicted, width, height) {
+	const n = width * height;
+	const step = Math.max(1, Math.floor(n / 4096));
+	const samples = [];
+	for (let i = 0; i < n; i += step) samples.push(predicted[i]);
+	samples.sort((a, b) => a - b);
+	const lo = samples[Math.floor((samples.length - 1) * TAIL)];
+	const hi = samples[Math.ceil((samples.length - 1) * (1 - TAIL))];
+	const scale = hi > lo ? 1 / (hi - lo) : 0;
+	const data = new Float32Array(n);
+	for (let i = 0; i < n; i++) data[i] = Math.min(1, Math.max(0, (predicted[i] - lo) * scale));
+	return {
+		data,
+		width,
+		height
+	};
+}
 const IMAGENET_BGR_MEAN = [
 	103.53,
 	116.28,
@@ -711,6 +754,21 @@ const PREPROCESS_BY_FAMILY = {
 			255
 		],
 		padValue: 0
+	},
+	"depth-anything": {
+		fit: "stretch",
+		channels: "rgb",
+		mean: [
+			123.675,
+			116.28,
+			103.53
+		],
+		std: [
+			58.395,
+			57.12,
+			57.375
+		],
+		padValue: 0
 	}
 };
 /** True for the families `VisionRunner` can preprocess and decode itself. */
@@ -2848,6 +2906,15 @@ var VisionRunner = class VisionRunner$1 {
 			...this.featherRadius !== void 0 ? { featherRadius: this.featherRadius } : {}
 		});
 	}
+	/** Relative depth of the whole frame (Depth Anything V2 Small), near = 1, at the model's resolution. */
+	async depth(image) {
+		const key = "depth-anything-v2-s";
+		const input = depthInputSize(image.width, image.height, VISION_MODELS[key].input[1]);
+		const { outputs } = await this.infer(key, image, input);
+		const predicted = output(outputs, "predicted_depth", key);
+		const dims = predicted.dims;
+		return decodeDepth(predicted.data, dims[dims.length - 1] ?? input[0], dims[dims.length - 2] ?? input[1]);
+	}
 	close() {
 		if (!this._ownsCore) return;
 		const core = this._core;
@@ -2897,9 +2964,9 @@ var VisionRunner = class VisionRunner$1 {
 	* 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) {
+	infer(key, image, input) {
 		const queue = this._core.runQueue;
-		const run = (queue.get(key) ?? Promise.resolve()).then(() => this.inferNow(key, image), () => this.inferNow(key, image));
+		const run = (queue.get(key) ?? Promise.resolve()).then(() => this.inferNow(key, image, input), () => this.inferNow(key, image, input));
 		const tail = run.catch(() => void 0);
 		queue.set(key, tail);
 		tail.then(() => {
@@ -2907,11 +2974,11 @@ var VisionRunner = class VisionRunner$1 {
 		});
 		return run;
 	}
-	async inferNow(key, frame) {
+	async inferNow(key, frame, input) {
 		const session = await this.session(key);
 		const desc = VISION_MODELS[key];
 		if (!isPreprocessFamily(desc.family)) throw new Error(`VisionRunner cannot run '${desc.family}' models; use the family's own tracker (e.g. Sam2Tracker or Sam3Tracker from @framefields/vision-sam).`);
-		const spec = preprocessSpec(desc.family, desc.input);
+		const spec = preprocessSpec(desc.family, input ?? desc.input);
 		const dims = [
 			1,
 			3,
@@ -3074,8 +3141,9 @@ function output(outputs, name, key) {
 /**
 * Where a render-time Vision effect finds subject masks someone already
 * computed for its clip (`comp.vision(clip)` in framefields), so a matte layer
-* reuses them instead of segmenting the frame again, and a skeleton layer draws
-* the pose matched to that subject instead of the first person it detects. Set
+* reuses them instead of segmenting the frame again, a skeleton layer draws
+* the pose matched to that subject instead of the first person it detects, and
+* a depth layer shows the depth analysed for each frame (not one behind). Set
 * on the Vision effect instance under this key; the renderer reads it from the effect.
 */
 const CLIP_SUBJECT = Symbol.for("framefields.vision.clipSubject");
@@ -4312,1008 +4380,5 @@ var VisionNode = class VisionNode$1 {
 };
 
 //#endregion
-//#region ../../nodes/node-vision/dist/renderers-Ao0SpHQm.mjs
-let scratchValues = new Uint8Array(0);
-let scratchLengths = new Uint32Array(0);
-function encodeMask(mask, width, height) {
-	if (scratchValues.length < mask.length) {
-		scratchValues = new Uint8Array(mask.length);
-		scratchLengths = new Uint32Array(mask.length);
-	}
-	const values = scratchValues;
-	const lengths = scratchLengths;
-	let runs = 0;
-	let start = 0;
-	for (let i = 1; i <= mask.length; i++) if (i === mask.length || mask[i] !== mask[start]) {
-		values[runs] = mask[start];
-		lengths[runs] = i - start;
-		runs++;
-		start = i;
-	}
-	return {
-		width,
-		height,
-		values: values.slice(0, runs),
-		lengths: lengths.slice(0, runs)
-	};
-}
-function decodeMask(rle) {
-	const out = new Uint8Array(rle.width * rle.height);
-	let at = 0;
-	for (let r = 0; r < rle.values.length; r++) {
-		const end = at + rle.lengths[r];
-		if (rle.values[r] !== 0) out.fill(rle.values[r], at, end);
-		at = end;
-	}
-	return out;
-}
-function rleBytes(rle) {
-	return rle.values.byteLength + rle.lengths.byteLength;
-}
-function toCachedMask(mask) {
-	const { mask: data, ...rest } = mask;
-	return {
-		...rest,
-		rle: encodeMask(data, mask.width, mask.height)
-	};
-}
-function fromCachedMask(mask) {
-	const { rle, ...rest } = mask;
-	return {
-		...rest,
-		mask: decodeMask(rle)
-	};
-}
-function resultBytes(result) {
-	let bytes = 512 + result.detections.length * 128 + result.objects.length * 256;
-	for (const m of result.masks ?? []) bytes += rleBytes(m.rle);
-	if (result.subject) bytes += rleBytes(result.subject.mask.rle);
-	return bytes;
-}
-/** Results by source (node + inference settings) and frame, least recently used out first. */
-var VisionFrameCache = class {
-	entries = /* @__PURE__ */ new Map();
-	bytes = 0;
-	constructor(maxBytes = 256 * 1024 * 1024) {
-		this.maxBytes = maxBytes;
-	}
-	get(source, frame) {
-		const key = `${source}#${frame}`;
-		const hit = this.entries.get(key);
-		if (hit) {
-			this.entries.delete(key);
-			this.entries.set(key, hit);
-		}
-		return hit;
-	}
-	set(source, frame, result) {
-		const key = `${source}#${frame}`;
-		const old = this.entries.get(key);
-		if (old) {
-			this.bytes -= resultBytes(old);
-			this.entries.delete(key);
-		}
-		this.entries.set(key, result);
-		this.bytes += resultBytes(result);
-		for (const [k, v] of this.entries) {
-			if (this.bytes <= this.maxBytes) break;
-			this.entries.delete(k);
-			this.bytes -= resultBytes(v);
-		}
-	}
-	clear() {
-		this.entries.clear();
-		this.bytes = 0;
-	}
-	get size() {
-		return this.entries.size;
-	}
-};
-/**
-* GPU composite for the mask-family modes: the picture times the subject mask,
-* in one full-screen pass. Replaces building the RGBA result on the CPU and
-* uploading it; only the 8-bit mask goes to the GPU.
-*
-*  - matte: picture × mask (premultiplied, so the background is transparent)
-*  - mask:  white silhouette (rgb = mask, a = 1)
-*  - crop:  matte, with the subject's bounding box stretched to the frame
-*/
-const WGSL = `
-struct Params {
-	mode: u32,          // 0 matte, 1 mask, 2 crop
-	_pad: u32,
-	cropMin: vec2<f32>, // uv of the subject bounds (crop)
-	cropMax: vec2<f32>,
-	_pad2: vec2<f32>,
-};
-
-@group(0) @binding(0) var<uniform> params: Params;
-@group(0) @binding(1) var picture: texture_2d<f32>;
-@group(0) @binding(2) var mask: texture_2d<f32>;
-@group(0) @binding(3) var samp: sampler;
-
-struct VSOut {
-	@builtin(position) pos: vec4<f32>,
-	@location(0) uv: vec2<f32>,
-};
-
-@vertex fn vs(@builtin(vertex_index) i: u32) -> VSOut {
-	var p = array<vec2<f32>, 3>(vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
-	var out: VSOut;
-	out.pos = vec4(p[i], 0.0, 1.0);
-	out.uv = vec2(p[i].x * 0.5 + 0.5, 0.5 - p[i].y * 0.5);
-	return out;
-}
-
-@fragment fn fs(in: VSOut) -> @location(0) vec4<f32> {
-	var uv = in.uv;
-	if (params.mode == 2u) {
-		uv = mix(params.cropMin, params.cropMax, uv);
-	}
-	let m = textureSampleLevel(mask, samp, uv, 0.0).r;
-	if (params.mode == 1u) {
-		return vec4(m, m, m, 1.0);
-	}
-	return textureSampleLevel(picture, samp, uv, 0.0) * m;
-}
-`;
-var MatteCompositor = class {
-	pipeline;
-	sampler;
-	uniforms = [];
-	uniformIndex = 0;
-	/** One 8-bit mask texture per node, rewritten each frame. */
-	masks = /* @__PURE__ */ new Map();
-	constructor(device, format) {
-		this.device = device;
-		const module = device.createShaderModule({
-			label: "vision_matte_composite",
-			code: WGSL
-		});
-		this.pipeline = device.createRenderPipeline({
-			label: "vision_matte_composite",
-			layout: "auto",
-			vertex: {
-				module,
-				entryPoint: "vs"
-			},
-			fragment: {
-				module,
-				entryPoint: "fs",
-				targets: [{ format }]
-			},
-			primitive: { topology: "triangle-list" }
-		});
-		this.sampler = device.createSampler({
-			magFilter: "linear",
-			minFilter: "linear"
-		});
-	}
-	/** Uploads a frame-sized 0..255 mask for `key` and returns its texture. */
-	uploadMask(key, mask, width, height) {
-		let tex = this.masks.get(key);
-		if (!tex || tex.width !== width || tex.height !== height) {
-			tex?.destroy();
-			tex = this.device.createTexture({
-				label: `vision_mask_${key}`,
-				size: [width, height],
-				format: "r8unorm",
-				usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
-			});
-			this.masks.set(key, tex);
-		}
-		const aligned = Math.ceil(width / 256) * 256;
-		let bytes = mask;
-		if (aligned !== width) {
-			bytes = new Uint8Array(aligned * height);
-			for (let y = 0; y < height; y++) bytes.set(mask.subarray(y * width, (y + 1) * width), y * aligned);
-		}
-		this.device.queue.writeTexture({ texture: tex }, bytes.buffer, {
-			offset: bytes.byteOffset,
-			bytesPerRow: aligned,
-			rowsPerImage: height
-		}, {
-			width,
-			height
-		});
-		return tex;
-	}
-	/** Clears `target` and draws `picture` through `mask` into it. */
-	draw(encoder$1, 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$1.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();
-	}
-};
-/**
-* 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;
-/** 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, 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();
-/**
-* 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 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) {
-	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).
-* Nodes with the same model options share sessions; decode options (classes,
-* confidence, …) get a derived runner over the same sessions.
-*/
-function getSharedRunner(op) {
-	const modelOptions = {
-		variant: op.variant,
-		modelsDir: op.modelsDir,
-		baseUrl: op.baseUrl
-	};
-	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 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
-		}))
-	})) };
-}
-/** Case-insensitive class filter, as the runner's decode applies it. */
-function matchesClasses(category, classes) {
-	if (!classes) return true;
-	const c = category.toLowerCase();
-	return classes.some((k) => k.toLowerCase() === c);
-}
-/** 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: 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;
-	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 compositionFrame = props.compositionFrame ?? frameIdx;
-	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 clipSubject = isMatteMode && !visionBundle && !wantsPose && !wantsSelfie && op.keyBackground !== true ? clipSubjectFor(effectKey, props.sourceTimeSec === void 0 ? frameIdx : props.sourceTimeSec * fps, fps, targetWidth, targetHeight) : void 0;
-	const clipPose = mode === "skeleton" && !visionBundle ? clipPoseFor(effectKey, props.sourceTimeSec === void 0 ? frameIdx : props.sourceTimeSec * fps, fps, targetWidth, targetHeight) : void 0;
-	const fromClip = clipSubject !== void 0 || clipPose !== void 0;
-	const cacheable = !fromClip && !wantsSelfie && !wantsPose && (wantsDetection || wantsSegmentation);
-	const source = cacheable ? cacheSource(nodeKeyStr, childMedia, op, targetWidth, targetHeight) : "";
-	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;
-	};
-	const heldFrame = hasPreviousFrame ? heldFrameByNode.get(nodeKeyStr) : void 0;
-	let cached = lookup(frameIdx);
-	const exact = fromClip || cached !== void 0;
-	if (!cached) cached = lookup(heldFrame);
-	let heldTex;
-	if (isMatteMode && hasPreviousFrame && !exact) {
-		heldTex = heldTexture(ctx.device, nodeKeyStr, childTex);
-		encoder$1.copyTextureToTexture({ texture: childTex }, { texture: heldTex }, [
-			targetWidth,
-			targetHeight,
-			1
-		]);
-	}
-	let frame;
-	let framePixels = null;
-	if (hasPreviousFrame && !cached && !fromClip) {
-		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([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$1, 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 (fromClip) {
-		subject = clipSubject ?? void 0;
-		if (subject) lastSubjectByNode.set(nodeKeyStr, {
-			mask: subject,
-			frame: frameIdx
-		});
-		else lastSubjectByNode.delete(nodeKeyStr);
-	} else 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 (frame) {
-		const runner = getSharedRunner(op);
-		const image = frame;
-		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
-			});
-		}
-		let subjectMasks = [];
-		if (wantsSegmentation) {
-			const subjectFromAllClasses = isMatteMode && op.matteSource !== "selfie" && op.classes !== void 0;
-			const segRes = await (subjectFromAllClasses ? getSharedRunner({
-				...op,
-				classes: void 0
-			}) : runner).segment(image);
-			frameMasks = assignMasksToTracks(subjectFromAllClasses ? segRes.masks.filter((m) => matchesClasses(m.category, op.classes)) : segRes.masks, frameObjects);
-			subjectMasks = subjectFromAllClasses ? segRes.masks : frameMasks;
-			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(subjectMasks.length > 0 ? subjectMasks : visionBundle?.getMaskResult(frameIdx) ?? [], { classes: op.classes }), nodeKeyStr, frameIdx);
-			const threshold = keyThresholdAt(heldFrame ?? frameIdx);
-			if (subject && threshold !== void 0 && framePixels) 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$1, 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$1, matteTex.createView(), picture, maskTex, mode, mode === "crop" ? maskBounds(subject) ?? void 0 : void 0);
-		visionBundle?.setStencilTexture(matteTex);
-		const outPass$1 = ctx.renderer.beginFrame(encoder$1, 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 keypoints = clipPose !== void 0 ? clipPose : (visionBundle?.getPoseResult(frameIdx) ?? currentPoseRes)?.people[0]?.keypoints;
-		const skelPass = ctx.renderer.beginFrame(encoder$1, targetView, {
-			r: 0,
-			g: 0,
-			b: 0,
-			a: 0
-		}, targetWidth, targetHeight, "clear");
-		if (keypoints && keypoints.length > 0) {
-			const skelTex = sharedSkeletonRenderer.renderToTexture(keypoints, {
-				width: targetWidth,
-				height: targetHeight
-			});
-			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$1, 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$1, 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();
-};
-/**
-* The subject a linked `comp.vision` clip holds for a source frame (see
-* CLIP_SUBJECT). Its mask is in source pixels; the composite samples it by
-* uv, so it fits any target of the same aspect. Other shapes fall back.
-*/
-function clipSubjectFor(effect, frame, fps, width, height) {
-	const source = linkedClip(effect);
-	const subject = source?.subject(frame, fps);
-	if (!subject || !source) return subject;
-	return fitsTarget(source, subject.width / subject.height, width / height) ? subject : void 0;
-}
-/**
-* The pose a linked `comp.vision` clip matched to its subject for a source
-* frame, normalized to the source; it fits targets of the same aspect.
-*/
-function clipPoseFor(effect, frame, fps, width, height) {
-	const source = linkedClip(effect);
-	const pose = source?.pose?.(frame, fps);
-	if (!pose || !source) return pose === null ? null : void 0;
-	return fitsTarget(source, pose.width / pose.height, width / height) ? pose.keypoints : void 0;
-}
-function linkedClip(effect) {
-	return effect?.[CLIP_SUBJECT];
-}
-/** Source results map onto a target of the same aspect; a prompted clip must not fall back. */
-function fitsTarget(source, sourceAspect, targetAspect) {
-	if (Math.abs(sourceAspect / targetAspect - 1) < .01) return true;
-	if (source.exact) throw new Error("A prompted clip matte requires the source aspect ratio. Apply layout cropping after the source matte.");
-	return false;
-}
-/** Adapts a Selfie Segmenter matte to the instance-mask shape the composite path takes. */
-function personMatteAsMask(matte) {
-	if (!matte || matte.coverage <= 0) return void 0;
-	const area = Math.round(matte.coverage * matte.width * matte.height);
-	return {
-		category: "person",
-		mask: matte.mask,
-		width: matte.width,
-		height: matte.height,
-		area,
-		coverage: matte.coverage,
-		detectionIndex: -1
-	};
-}
-var renderers_default = defineRenderer({ WebGPURenderer: VisionWebGPURenderer });
-
-//#endregion
-export { pinNodeToObject as _, COCO17_KEYPOINT_NAMES as a, SpatialLandmarkTransformer as c, VisionNode as d, VisionRunner as f, pinNodeToLandmark as g, mergeSubjectMask as h, COCO17_KEYPOINTS as i, TemporalObjectTracker as l, maskObject as m, CLIP_SUBJECT as n, PoseSkeletonRenderer as o, analyzeSequence as p, COCO17_BONES as r, SegmentationTexturePool as s, renderers_default as t, VisionBundle as u, COCO_CLASSES as v };
-//# sourceMappingURL=renderer-B2P1vgb7.mjs.map
+export { setVisionDevice as A, matchPoseToTracks as C, readTexturePixels as D, pinNodeToObject as E, registerVisionModel as F, varint as M, COCO_CLASSES as N, readVarint as O, VISION_MODELS as P, maskObject as S, pinNodeToLandmark as T, fields as _, PoseSkeletonRenderer as a, lengthDelimited as b, TemporalObjectTracker as c, VisionNode as d, VisionRunner as f, encoder as g, createDefaultSessionProvider as h, COCO17_KEYPOINT_NAMES as i, strings as j, sessionCompute as k, VisionBundle as l, concat as m, COCO17_BONES as n, SegmentationTexturePool as o, analyzeSequence as p, COCO17_KEYPOINTS as r, SpatialLandmarkTransformer as s, CLIP_SUBJECT as t, VisionModelStore as u, firstString as v, mergeSubjectMask as w, maskBounds as x, imageToTensor as y };
+//# sourceMappingURL=src-BU6vm9sP-DFJ3phW0.mjs.map