framefields 2.9.2 → 2.9.3

package/dist/dist-Dq5TkNDI.mjs

@@ -0,0 +1,1434 @@
+import { F as registerVisionModel, M as varint, O as readVarint, P as VISION_MODELS, _ as fields, b as lengthDelimited, g as encoder, h as createDefaultSessionProvider, j as strings, k as sessionCompute, m as concat, u as VisionModelStore, v as firstString, y as imageToTensor } from "./src-Bnr8DUC--DzkRGA62.mjs";
+import { z } from "zod";
+import { Tokenizer } from "@huggingface/tokenizers";
+
+//#region ../vision-sam/dist/index.mjs
+const SAM_LICENSE_TERMS_URL = "https://github.com/facebookresearch/sam3/blob/main/LICENSE";
+/**
+* Ensures that the user has explicitly accepted Meta's SAM License terms before
+* downloading SAM 3 weights or performing inference. SAM 2.1's weights are Apache-2.0 and
+* need no acceptance.
+*/
+function assertSamLicenseAccepted(context = "SAM 3", options) {
+	if (options?.acceptLicense) return;
+	if (typeof process !== "undefined" && process.env?.FRAMEFIELDS_ACCEPT_SAM_LICENSE === "1") return;
+	throw new Error(`Meta SAM License agreement required for ${context}:\nSAM 3's model weights are subject to Meta's SAM License.\nReview terms at: ${SAM_LICENSE_TERMS_URL}\nTo download and run SAM 3 in Framefields, you must explicitly accept the terms by:\n  1. Passing 'acceptLicense: true' (or 'acceptSamLicense: true' in ClipVision options), or\n  2. Setting the environment variable FRAMEFIELDS_ACCEPT_SAM_LICENSE=1.`);
+}
+/**
+* Diffusion Studio's fp16 video exports of Meta SAM 2.1 (Apache-2.0). Tiny is built for
+* speed at 512² (32×32 features); Small runs SAM 2's native 1024² (64×64), resolving small
+* objects, thin structures and identity after cuts better at roughly 4× the encoder and
+* 16× the memory-attention work.
+*/
+const SAM2_EXPORTS = {
+	tiny: {
+		repo: "diffusionstudio/sam2.1-tiny-video-onnx-fp16",
+		revision: "66673b5db39371b7dd7847f4d3bc0d4f4179b79e",
+		size: 512,
+		name: "Hiera Tiny"
+	},
+	small: {
+		repo: "diffusionstudio/sam2.1-small-video-onnx-fp16",
+		revision: "927ecec6e6ae2727d0af7720eefdb07f2efe4689",
+		size: 1024,
+		name: "Hiera Small"
+	}
+};
+/**
+* The encoder precision each backend runs fastest. Measured on an M1 Pro (one 1008² frame):
+* WebGPU fp16 3.65 s, q4f16 4.43 s, q4 6.63 s, int8 140 s (its ops fall back to the CPU);
+* fp16 is also the closest to full precision. On WebGPU, 4-bit weights are dequantized
+* before every matmul, so they only save memory. CUDA runs fp16 on tensor cores. CPUs have
+* no fast fp16 path, so they get fp32-activation q4.
+*/
+const SAM3_ENCODER = {
+	webgpu: "fp16",
+	cuda: "fp16",
+	cpu: "q4"
+};
+const SAM_LICENSE = "Meta SAM License";
+const hf = (repo, revision, path) => `https://huggingface.co/${repo}/resolve/${revision}/${path}`;
+const sam2 = (model$1, graph, [path, bytes, sha256]) => {
+	const { repo, revision, size, name } = SAM2_EXPORTS[model$1];
+	const key = `sam2.1-${model$1}-${graph}`;
+	return {
+		key,
+		family: "sam2",
+		filename: `${key}${path.slice(path.lastIndexOf("."))}`,
+		url: hf(repo, revision, path),
+		bytes,
+		sha256,
+		input: [size, size],
+		source: `Meta SAM 2.1 ${name} (Apache-2.0), Diffusion Studio ${size}px fp16 video export`,
+		license: "Apache-2.0"
+	};
+};
+const sam3 = (repo, revision) => (key, filename, [path, bytes, sha256]) => ({
+	key,
+	family: "sam3",
+	filename,
+	url: hf(repo, revision, path),
+	bytes,
+	sha256,
+	input: [1008, 1008],
+	source: `Meta SAM 3 (${SAM_LICENSE}), pinned ${repo} ONNX export`,
+	license: SAM_LICENSE
+});
+const tracker = sam3("onnx-community/sam3-tracker-ONNX", "429305c8a5b3de597243d919a07e4e6bdcd00ef7");
+/** The tracker encoder at `precision`: its graph and the weights file the graph names. */
+function encoder$1(precision, [graphBytes, graphSha], [dataBytes, dataSha]) {
+	const { graph, data } = sam3EncoderFiles(precision);
+	return [tracker(`sam3-vision_encoder-${precision}`, `sam3-${graph}`, [
+		`onnx/${graph}`,
+		graphBytes,
+		graphSha
+	]), tracker(`sam3-vision_encoder-${precision}-data`, `sam3-${data}`, [
+		`onnx/${data}`,
+		dataBytes,
+		dataSha
+	])];
+}
+/** File names of the encoder at `precision`; the graph refers to its weights by `data`. */
+function sam3EncoderFiles(precision) {
+	const graph = `vision_encoder_${precision}.onnx`;
+	return {
+		graph,
+		data: `${graph}_data`
+	};
+}
+const video = sam3("jax-image-tools/sam3-video-onnx", "e942689a73d942f83c69b5965881cb3a0f6153ba");
+const support = sam3("RamRom/sam3-onnx", "68ce2746e903966a88549cdd08ab554ff9162db0");
+const text$1 = sam3("danilobukvic/sam3-text-onnx", "fe8f8e123bfa42d4e57d14fa2f4928a4c60f4665");
+const SUPPORT_GRAPH = "bundles/sam3-base-video-tracking-ortcuda-v2/graphs/base_tracker_preview_single1.onnx";
+const SAM_MODELS = [
+	sam2("tiny", "constants", [
+		"constants.json",
+		9781,
+		"67583810f4b80b762285377a5cc1066bbe19cdf8ef7fc87ff6aa78fc79830ef2"
+	]),
+	sam2("tiny", "vision_encoder", [
+		"onnx/vision_encoder.onnx",
+		58385353,
+		"24e9ccf5994be5c8dd93ebe771a4cc4f8bb122d0524555ac3ba4e7141710b133"
+	]),
+	sam2("tiny", "mask_decoder", [
+		"onnx/mask_decoder.onnx",
+		8898805,
+		"6bc158b0d028777ca2e25203ece0f27429c436de39a5c7fe301b3858d6059789"
+	]),
+	sam2("tiny", "memory_encoder", [
+		"onnx/memory_encoder.onnx",
+		2807753,
+		"8b2bb6810444cee684ef938b7464c5645653f236014f5497c3db3654818cc7ce"
+	]),
+	sam2("tiny", "memory_attention", [
+		"onnx/memory_attention.onnx",
+		13029470,
+		"67c4e4da01bc7f501b88294bb19a8200362915ece04e9d7e367a437658f342c9"
+	]),
+	sam2("tiny", "pointer_tpos", [
+		"onnx/pointer_tpos.onnx",
+		34228,
+		"3ab5bfce40ed01208301b2d8f596b9c9f7f493dcd7e09ef01ec22e5be3694bd7"
+	]),
+	sam2("small", "constants", [
+		"constants.json",
+		9820,
+		"09397f7251c159b64a2d581cc3ea0dbb3cf720c2e60777cb14e244405ed1c305"
+	]),
+	sam2("small", "vision_encoder", [
+		"onnx/vision_encoder.onnx",
+		83679474,
+		"fb570036f5afac59ef20848958b075c84da746e333efd863104d94604652efc4"
+	]),
+	sam2("small", "mask_decoder", [
+		"onnx/mask_decoder.onnx",
+		8910345,
+		"999b3b47bf2e924d522ed6cc011fa2c9b651754cc07895eb0da16a28a5ce7c4d"
+	]),
+	sam2("small", "memory_encoder", [
+		"onnx/memory_encoder.onnx",
+		2807884,
+		"f36324e383dbf21fcd549169aedf698db00c307fd9a49538c0e5f0aa168e4f99"
+	]),
+	sam2("small", "memory_attention", [
+		"onnx/memory_attention.onnx",
+		16175204,
+		"6666be8ca502b5c16e9a113d3d3934996d32f27e93bee5e66a8317fcceec9985"
+	]),
+	sam2("small", "pointer_tpos", [
+		"onnx/pointer_tpos.onnx",
+		34228,
+		"f9c1b36e0aa9dc6b7c05b02a8fdaa17cc671d967ffcacc14fcd3177e65ec25e9"
+	]),
+	...encoder$1("fp16", [1263005, "f8c52be6de99124bb17f25792054406abc482ce3502166f948d5c5849cd14d02"], [934729728, "4b021a4d3068c9e9153f2f2fcc9e6d280156228671c00ab6c2ddfa737da7f151"]),
+	...encoder$1("q4f16", [1307816, "4b96732adab3d7d70ac0964ce540a61fad097fbc10c9b27612f47d676877cefc"], [295622656, "d1d60808376dbd48e34cf89feaee708c13abed229f2398ab512149db34fdab07"]),
+	...encoder$1("q4", [1320396, "b80cb1cb6ab80efe646ad49ffa11d398af76e8912eb966971932ef2d8e7fe11b"], [368954368, "be632cacb4a82ef8be28285e49821b9dd7f96e3231cb90df631890f367110555"]),
+	video("sam3-mask_decoder", "sam3-mask_decoder.onnx", [
+		"mask_decoder.onnx",
+		17809322,
+		"4dff9a588828eeceba4285be85fb9c2a0306447ad642d02b1d8f6bfff1f19af9"
+	]),
+	video("sam3-memory_encoder", "sam3-memory_encoder.onnx", [
+		"memory_encoder.onnx",
+		5587704,
+		"78146118c2f91073489926bb587a81f129c391b2e0d1dba3aede6fbaa699498f"
+	]),
+	video("sam3-memory_attention", "sam3-memory_attention.onnx", [
+		"memory_attention.onnx",
+		34592488,
+		"8b24dc20acbb485b81f0e67ed0980b747aaa836707ccff4567a87e59c0ca1c24"
+	]),
+	support("sam3-support", "sam3-base_tracker_preview_single1.onnx", [
+		SUPPORT_GRAPH,
+		3064674,
+		"d80c1958175d5de6ca72f5b95d24d853dbdb511e0851d5918a4dcf7ed000f3ea"
+	]),
+	support("sam3-support-data", "sam3-base_tracker_preview_single1.onnx.data", [
+		`${SUPPORT_GRAPH}.data`,
+		63668224,
+		"618f62fbac368e863ee295526efd84ca768fb9914c7e1a5d9f1fb0f28837dda1"
+	]),
+	text$1("sam3-text-vision_encoder", "sam3-vision_encoder_int4_fp16attn.onnx", [
+		"vision_encoder_int4_fp16attn.onnx",
+		5216609,
+		"9d148134938a6a284a829733774d3b1356a706a3397bb1d4be240bf041e3ac0e"
+	]),
+	text$1("sam3-text-vision_encoder-data", "sam3-vision_encoder_int4_fp16attn.onnx.data", [
+		"vision_encoder_int4_fp16attn.onnx.data",
+		292836352,
+		"b89c9156064e926761f29be3f87b160fd34f4c93f1de46593295d155621829a2"
+	]),
+	text$1("sam3-text-encoder", "sam3-text_encoder_int8.onnx", [
+		"text_encoder_int8.onnx",
+		357021801,
+		"c0baf8a4165ecc4039bee9389903723e74a68d617d685a4f1dbfc21c58bb4121"
+	]),
+	text$1("sam3-text-decoder", "sam3-decoder_int8.onnx", [
+		"decoder_int8.onnx",
+		26804694,
+		"d721e7b643bb3ee2c48a59d520401c035c702cfbb13cb7f50fa103f0beb27af8"
+	]),
+	text$1("sam3-tokenizer", "sam3-tokenizer.json", [
+		"tokenizer.json",
+		3642073,
+		"6d9109cc838977f3ca94a379eec36aecc7c807e1785cd729660ca2fc0171fb35"
+	]),
+	text$1("sam3-tokenizer-config", "sam3-tokenizer_config.json", [
+		"tokenizer_config.json",
+		799,
+		"39670ad98457fe8f14ca59f6bb74591e9fc850974380a63993e5b8ffc865baa2"
+	])
+];
+/** Registers the SAM descriptors into the shared vision registry (idempotent). */
+function ensureSamModelsRegistered() {
+	for (const descriptor of SAM_MODELS) if (!VISION_MODELS[descriptor.key]) registerVisionModel(descriptor);
+}
+var Sam2MemoryBank = class {
+	seed;
+	recent = [];
+	constructor(temporal) {
+		this.temporal = temporal;
+	}
+	remember(memory, prompted) {
+		if (prompted) {
+			this.seed = memory;
+			this.recent = [];
+		} else {
+			this.recent.push(memory);
+			if (this.recent.length > 15) this.recent.shift();
+		}
+	}
+	assemble(frame, frameCount = 16) {
+		if (!this.seed) throw new Error("SAM 2 must be prompted before propagation.");
+		const newest = [...this.recent].reverse();
+		const blocks = [this.seed, ...newest.slice(0, 6)];
+		while (blocks.length < 7) blocks.push(blocks[1] ?? this.seed);
+		const pointers = [this.seed, ...newest].slice(0, 16);
+		while (pointers.length < 16) pointers.push(pointers[pointers.length - 1]);
+		const length = this.seed.tokens.length;
+		const memory = new Float32Array(length * 7 + 16 * 256);
+		const positions = new Float32Array(memory.length);
+		for (const [slot, block] of blocks.entries()) {
+			memory.set(block.tokens, slot * length);
+			const available = Math.min(slot, this.recent.length);
+			const row = this.temporal[slot === 0 || available === 0 ? 6 : available - 1];
+			writePositions(positions, slot * length, block.positions, row);
+		}
+		const distances = new Float32Array(16);
+		for (const [i, entry] of pointers.entries()) {
+			memory.set(entry.pointer, length * 7 + i * 256);
+			distances[i] = Math.abs(frame - entry.frame) / Math.max(1, Math.min(frameCount, 16) - 1);
+		}
+		return {
+			memory,
+			positions,
+			distances
+		};
+	}
+};
+/** NCHW features to the sequence-major layout consumed by memory attention. */
+function sam2Tokens(data) {
+	const count = data.length / 256;
+	const result = new Float32Array(data.length);
+	for (let channel = 0; channel < 256; channel++) for (let token = 0; token < count; token++) result[token * 256 + channel] = data[channel * count + token] ?? 0;
+	return result;
+}
+function writePositions(target, offset, spatial, temporal) {
+	if (!temporal || temporal.length !== 64) throw new Error("Invalid SAM 2 temporal encoding.");
+	for (let i = 0; i < spatial.length; i++) target[offset + i] = (spatial[i] ?? 0) + (temporal[i % 64] ?? 0);
+}
+function validateSam2Prompts(prompts) {
+	if (prompts.length === 0) throw new Error("SAM 2 requires at least one prompt.");
+	let previous = -1;
+	for (const prompt of prompts) {
+		if (!Number.isSafeInteger(prompt.frame) || prompt.frame <= previous) throw new Error("SAM 2 prompt frames must be nonnegative, unique and increasing.");
+		previous = prompt.frame;
+		if (prompt.points.length === 0) throw new Error("SAM 2 prompts need points or a box.");
+		for (const point of prompt.points) validatePoint(point);
+		const corners = prompt.points.filter((point) => point.label >= 2);
+		if (corners.length && (corners.length !== 2 || corners[0]?.label !== 2 || corners[1]?.label !== 3 || corners[0].x >= corners[1].x || corners[0].y >= corners[1].y)) throw new Error("SAM 2 boxes need top-left (2) and bottom-right (3) corners.");
+	}
+}
+function validatePoint(point) {
+	if (![
+		0,
+		1,
+		2,
+		3
+	].includes(point.label) || !Number.isFinite(point.x) || !Number.isFinite(point.y) || point.x < 0 || point.x > 1 || point.y < 0 || point.y > 1) throw new Error("SAM 2 points require normalized coordinates and labels 0, 1, 2 or 3.");
+}
+const constantsSchema = z.object({
+	image_size: z.number().int().positive().multipleOf(16),
+	memory_frames: z.literal(7),
+	image_mean: z.tuple([
+		z.number(),
+		z.number(),
+		z.number()
+	]),
+	image_std: z.tuple([
+		z.number().positive(),
+		z.number().positive(),
+		z.number().positive()
+	]),
+	memory_temporal_positional_encoding: z.array(z.array(z.number()).length(64)).length(7)
+});
+const GRAPHS = [
+	"vision_encoder",
+	"mask_decoder",
+	"memory_encoder",
+	"memory_attention",
+	"pointer_tpos"
+];
+/** The pinned export revision of `model`: part of ClipVision's persistent cache identity. */
+function sam2Revision(model$1 = "tiny") {
+	return `sam2.1-${model$1}-${SAM2_EXPORTS[model$1].revision}`;
+}
+function floats(outputs, name) {
+	const tensor$2 = outputs[name];
+	if (!tensor$2 || !(tensor$2.data instanceof Float32Array)) throw new Error(`Missing SAM 2 float output: ${name}`);
+	return tensor$2.data;
+}
+function input(name, tensor$2) {
+	if (tensor$2.data instanceof BigInt64Array) throw new Error(`Unsupported SAM 2 input type: ${name}`);
+	return {
+		name,
+		data: tensor$2.data,
+		dims: tensor$2.dims
+	};
+}
+function tensor$1(name, data, dims) {
+	return {
+		name,
+		data,
+		dims
+	};
+}
+/** Complete pinned SAM 2.1 video graph pipeline (Tiny or Small), one explicitly selected object. */
+var Sam2Tracker = class Sam2Tracker$1 {
+	sessions = /* @__PURE__ */ new Map();
+	bank;
+	/** Model input side; image features are `size / 16` square, one memory token per cell. */
+	size;
+	tokens;
+	lastFrame = -1;
+	released = false;
+	constructor(constants, frameCount = 16) {
+		this.constants = constants;
+		this.frameCount = frameCount;
+		this.bank = new Sam2MemoryBank(constants.memory_temporal_positional_encoding);
+		this.size = constants.image_size;
+		this.tokens = (this.size / 16) ** 2;
+	}
+	static async create(options = {}) {
+		ensureSamModelsRegistered();
+		const store = options.store ?? new VisionModelStore(options);
+		const model$1 = options.model ?? "tiny";
+		if (!(model$1 in SAM2_EXPORTS)) throw new Error(`Unknown SAM 2.1 model "${model$1}"; use "tiny" or "small".`);
+		const bytes = await store.ensure(`sam2.1-${model$1}-constants`);
+		const constants = constantsSchema.parse(JSON.parse(new TextDecoder().decode(bytes)));
+		if (options.frameCount !== void 0 && (!Number.isSafeInteger(options.frameCount) || options.frameCount < 1)) throw new Error("SAM 2 frameCount must be a positive integer.");
+		const tracker$1 = new Sam2Tracker$1(constants, options.frameCount);
+		const provider = options.provider ?? createDefaultSessionProvider();
+		try {
+			for (const graph of GRAPHS) {
+				const session = await provider.createSession(await store.ensure(`sam2.1-${model$1}-${graph}`));
+				tracker$1.sessions.set(graph, session);
+			}
+			return tracker$1;
+		} catch (error) {
+			tracker$1.release();
+			throw error;
+		}
+	}
+	run(graph, inputs) {
+		const session = this.sessions.get(graph);
+		if (!session) throw new Error("SAM 2 tracker has been released.");
+		if (session.runMany) return session.runMany(inputs);
+		if (inputs.length === 1 && inputs[0]) return session.run(inputs[0]);
+		throw new Error("SAM 2 requires a session provider with runMany support.");
+	}
+	async process(image, frame, points) {
+		if (this.released) throw new Error("SAM 2 tracker has been released.");
+		if (!Number.isSafeInteger(frame) || frame < 0 || this.lastFrame >= 0 && frame !== this.lastFrame + 1) throw new Error("SAM 2 propagation requires consecutive source frames.");
+		if (points) validateSam2Prompts([{
+			frame,
+			points
+		}]);
+		if (this.lastFrame < 0 && !points) throw new Error("SAM 2 needs a prompt on its first frame.");
+		const { tensor: pixels } = imageToTensor(image, {
+			width: this.size,
+			height: this.size,
+			fit: "stretch",
+			channels: "rgb",
+			padValue: 0,
+			mean: this.constants.image_mean.map((v) => v * 255),
+			std: this.constants.image_std.map((v) => v * 255)
+		});
+		const vision = await this.run("vision_encoder", [tensor$1("pixel_values", pixels, [
+			1,
+			3,
+			this.size,
+			this.size
+		])]);
+		const conditioned = points ? vision.feats2_no_mem : await this.condition(vision, frame);
+		if (!conditioned || !vision.feats0 || !vision.feats1) throw new Error("Invalid SAM 2 vision outputs.");
+		const prompt = points ?? [{
+			x: 0,
+			y: 0,
+			label: -1
+		}];
+		const decoded = await this.run("mask_decoder", [
+			input("feats0", vision.feats0),
+			input("feats1", vision.feats1),
+			input("feats2_cond", conditioned),
+			tensor$1("input_points", Float32Array.from(prompt.flatMap((p) => [p.x * this.size, p.y * this.size])), [
+				1,
+				1,
+				prompt.length,
+				2
+			]),
+			tensor$1("input_labels", Int32Array.from(prompt.map((p) => p.label)), [
+				1,
+				1,
+				prompt.length
+			])
+		]);
+		await this.remember(vision, decoded, frame, points !== void 0);
+		this.lastFrame = frame;
+		return decodeSam2Mask(floats(decoded, "high_res_mask"), image.width, image.height, floats(decoded, "object_score_logits")[0] ?? -Infinity, floats(decoded, "iou")[0] ?? 0);
+	}
+	async condition(vision, frame) {
+		const bank = this.bank.assemble(frame, this.frameCount);
+		const positions = floats(await this.run("pointer_tpos", [tensor$1("normalized_diffs", bank.distances, [16])]), "pointer_pos");
+		for (let i = 0; i < 16; i++) for (let token = 0; token < 4; token++) bank.positions.set(positions.subarray(i * 64, (i + 1) * 64), 7 * this.tokens * 64 + (i * 4 + token) * 64);
+		const memoryLength = 7 * this.tokens + 64;
+		const conditioned = (await this.run("memory_attention", [
+			tensor$1("current_vision_features", sam2Tokens(floats(vision, "feats2")), [
+				this.tokens,
+				1,
+				256
+			]),
+			tensor$1("current_vision_position_embeddings", sam2Tokens(floats(vision, "vision_pos_embed")), [
+				this.tokens,
+				1,
+				256
+			]),
+			tensor$1("memory", bank.memory, [
+				memoryLength,
+				1,
+				64
+			]),
+			tensor$1("memory_pos", bank.positions, [
+				memoryLength,
+				1,
+				64
+			])
+		])).conditioned_feats;
+		if (!conditioned) throw new Error("Missing SAM 2 conditioned features.");
+		return conditioned;
+	}
+	async remember(vision, decoded, frame, prompted) {
+		if (!vision.feats2 || !decoded.high_res_mask) throw new Error("Invalid SAM 2 memory inputs.");
+		const memory = await this.run("memory_encoder", [
+			input("feats2", vision.feats2),
+			input("high_res_mask", decoded.high_res_mask),
+			tensor$1("object_score_logits", floats(decoded, "object_score_logits"), [1, 1]),
+			tensor$1("binarize", new Float32Array([prompted ? 1 : 0]), [])
+		]);
+		this.bank.remember({
+			frame,
+			tokens: floats(memory, "memory_tokens").slice(),
+			positions: floats(memory, "memory_pos").slice(),
+			pointer: floats(decoded, "object_pointer").slice()
+		}, prompted);
+	}
+	release() {
+		for (const session of this.sessions.values()) session.release();
+		this.sessions.clear();
+		this.released = true;
+	}
+};
+/** Bilinear resize of square logits before thresholding, matching SAM's source-image mask contract. */
+function decodeSam2Mask(logits, width, height, score, iou) {
+	const side = Math.round(Math.sqrt(logits.length));
+	if (side * side !== logits.length || side % 16 !== 0) throw new Error("Invalid SAM 2 mask shape.");
+	const last = side - 1;
+	const mask = new Uint8Array(width * height);
+	if (score > 0) for (let y = 0; y < height; y++) {
+		const sy = Math.max(0, Math.min(last, (y + .5) * side / height - .5));
+		const y0 = Math.floor(sy), y1 = Math.min(last, y0 + 1), fy = sy - y0;
+		for (let x = 0; x < width; x++) {
+			const sx = Math.max(0, Math.min(last, (x + .5) * side / width - .5));
+			const x0 = Math.floor(sx), x1 = Math.min(last, x0 + 1), fx = sx - x0;
+			const a = (logits[y0 * side + x0] ?? 0) * (1 - fx) + (logits[y0 * side + x1] ?? 0) * fx;
+			const b = (logits[y1 * side + x0] ?? 0) * (1 - fx) + (logits[y1 * side + x1] ?? 0) * fx;
+			mask[y * width + x] = a * (1 - fy) + b * fy > 0 ? 255 : 0;
+		}
+	}
+	return {
+		mask,
+		width,
+		height,
+		score,
+		iou
+	};
+}
+/** SAM 3's small prompt/position heads, assembled from the pinned upstream weights.
+* The video export omits dense prompts and learned temporal constants. These heads
+* restore the original operations, without approximating a semantic mask by clicks.
+*/
+function integer(field, value$1) {
+	return new Uint8Array([...varint(field * 8), ...varint(value$1)]);
+}
+function text(field, value$1) {
+	return lengthDelimited(field, encoder.encode(value$1));
+}
+function attribute(name, values) {
+	return lengthDelimited(5, concat([
+		text(1, name),
+		integer(20, 7),
+		lengthDelimited(8, new Uint8Array(values.flatMap(varint)))
+	]));
+}
+function intAttribute(name, value$1) {
+	return lengthDelimited(5, concat([
+		text(1, name),
+		integer(3, value$1),
+		integer(20, 2)
+	]));
+}
+function floatAttribute(name, value$1) {
+	const bytes = new Uint8Array(4);
+	new DataView(bytes.buffer).setFloat32(0, value$1, true);
+	return lengthDelimited(5, concat([
+		text(1, name),
+		new Uint8Array([21, ...bytes]),
+		integer(20, 1)
+	]));
+}
+function node(op, inputs, output, attrs = []) {
+	return lengthDelimited(1, concat([
+		...inputs.map((x) => text(1, x)),
+		text(2, output),
+		text(4, op),
+		...attrs
+	]));
+}
+function value(name, dims) {
+	const shape = concat(dims.map((d) => lengthDelimited(1, integer(1, d))));
+	return concat([text(1, name), lengthDelimited(2, lengthDelimited(1, concat([integer(1, 1), lengthDelimited(2, shape)])))]);
+}
+function scalar(name, amount) {
+	const data = new Float32Array([amount]);
+	return concat([
+		integer(2, 1),
+		text(8, name),
+		lengthDelimited(9, new Uint8Array(data.buffer))
+	]);
+}
+function model(nodes, inputs, outputs, weights) {
+	const graph = concat([
+		...nodes,
+		text(2, "framefields_sam3"),
+		...weights.map((w) => lengthDelimited(5, w)),
+		...inputs.map(([n, d]) => lengthDelimited(11, value(n, d))),
+		...outputs.map(([n, d]) => lengthDelimited(12, value(n, d)))
+	]);
+	return concat([
+		integer(1, 9),
+		lengthDelimited(7, graph),
+		lengthDelimited(8, integer(2, 18))
+	]);
+}
+function weightsFrom(modelBytes, external) {
+	const graph = fields(modelBytes).find((f) => f.number === 7);
+	if (!graph) throw new Error("SAM 3 constants graph is missing.");
+	const result = /* @__PURE__ */ new Map();
+	for (const entry of fields(graph.body).filter((f) => f.number === 5)) {
+		const fs = fields(entry.body), name = firstString(entry.body, 8);
+		if (!name || !/tracker\.(maskmem_tpos_enc|no_mem_embed|obj_ptr_tpos_proj|sam_prompt_encoder\.mask_downscaling)/.test(name)) continue;
+		const metadata = new Map(fs.filter((f) => f.number === 13).map((f) => [firstString(f.body, 1), firstString(f.body, 2)]));
+		const offset = Number(metadata.get("offset") ?? 0), length = Number(metadata.get("length") ?? 0);
+		const raw = fs.find((f) => f.number === 9)?.body ?? external.subarray(offset, offset + length);
+		const dataType = fs.find((f) => f.number === 2);
+		const dtype = dataType ? readVarint(dataType.raw, 1)[0] : 0;
+		if (![1, 10].includes(dtype)) throw new Error(`Unsupported SAM 3 weight type: ${name}`);
+		if (raw.length === 0 || raw.length % (dtype === 10 ? 2 : 4) !== 0) throw new Error(`Invalid SAM 3 weight: ${name}`);
+		const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+		const data = Float32Array.from({ length: raw.length / (dtype === 10 ? 2 : 4) }, (_, i) => {
+			if (dtype === 1) return view.getFloat32(i * 4, true);
+			const bits = view.getUint16(i * 2, true), sign = bits & 32768 ? -1 : 1, exponent = bits >> 10 & 31, fraction = bits & 1023;
+			if (exponent === 31) throw new Error(`Non-finite SAM 3 weight ${name}`);
+			return sign * (exponent === 0 ? fraction * 2 ** -24 : (1 + fraction / 1024) * 2 ** (exponent - 15));
+		});
+		const copy = new Uint8Array(data.buffer);
+		result.set(name, {
+			proto: concat([
+				...fs.filter((f) => ![
+					2,
+					9,
+					13,
+					14
+				].includes(f.number)).map((f) => f.raw),
+				integer(2, 1),
+				lengthDelimited(9, copy)
+			]),
+			data: new Float32Array(copy.buffer)
+		});
+	}
+	return result;
+}
+function sam3SupportGraphs(reference, external) {
+	const weights = weightsFrom(reference, external);
+	const get = (name) => {
+		const item = weights.get(`tracker.${name}`);
+		if (!item) throw new Error(`Missing SAM 3 weight ${name}`);
+		return item;
+	};
+	const nodes = [], denseWeights = [
+		scalar("sqrt2", Math.SQRT2),
+		scalar("one", 1),
+		scalar("half", .5)
+	];
+	let previous = "mask";
+	for (const [index, layer] of [
+		0,
+		3,
+		6
+	].entries()) {
+		const base = `sam_prompt_encoder.mask_downscaling.${layer}`;
+		for (const suffix of ["weight", "bias"]) denseWeights.push(get(`${base}.${suffix}`).proto);
+		const output = `conv${index}`;
+		nodes.push(node("Conv", [
+			previous,
+			`tracker.${base}.weight`,
+			`tracker.${base}.bias`
+		], output, [attribute("kernel_shape", layer === 6 ? [1, 1] : [2, 2]), attribute("strides", layer === 6 ? [1, 1] : [2, 2])]));
+		previous = output;
+		if (layer === 6) continue;
+		const norm = `sam_prompt_encoder.mask_downscaling.${layer + 1}`;
+		for (const suffix of ["weight", "bias"]) denseWeights.push(get(`${norm}.${suffix}`).proto);
+		nodes.push(node("Transpose", [previous], `nhwc${index}`, [attribute("perm", [
+			0,
+			2,
+			3,
+			1
+		])]), node("LayerNormalization", [
+			`nhwc${index}`,
+			`tracker.${norm}.weight`,
+			`tracker.${norm}.bias`
+		], `norm${index}`, [intAttribute("axis", 3), floatAttribute("epsilon", 1e-6)]), node("Transpose", [`norm${index}`], `nchw${index}`, [attribute("perm", [
+			0,
+			3,
+			1,
+			2
+		])]), node("Div", [`nchw${index}`, "sqrt2"], `div${index}`), node("Erf", [`div${index}`], `erf${index}`), node("Add", [`erf${index}`, "one"], `add${index}`), node("Mul", [`add${index}`, `nchw${index}`], `mul${index}`), node("Mul", [`mul${index}`, "half"], `gelu${index}`));
+		previous = `gelu${index}`;
+	}
+	nodes.push(node("Identity", [previous], "dense_prompt"));
+	const pointerWeights = [get("obj_ptr_tpos_proj.weight").proto, get("obj_ptr_tpos_proj.bias").proto];
+	return {
+		densePrompt: model(nodes, [["mask", [
+			1,
+			1,
+			288,
+			288
+		]]], [["dense_prompt", [
+			1,
+			256,
+			72,
+			72
+		]]], denseWeights),
+		pointerPosition: model([node("Gemm", [
+			"encoding",
+			"tracker.obj_ptr_tpos_proj.weight",
+			"tracker.obj_ptr_tpos_proj.bias"
+		], "position", [intAttribute("transB", 1)])], [["encoding", [16, 256]]], [["position", [16, 64]]], pointerWeights),
+		temporal: get("maskmem_tpos_enc").data,
+		noMemory: get("no_mem_embed").data
+	};
+}
+/** Replace the no-mask embedding by the actual dense prompt head's output. */
+function sam3DenseDecoder(modelBytes) {
+	const modelFields = fields(modelBytes), graph = modelFields.find((f) => f.number === 7);
+	if (!graph) throw new Error("Missing SAM 3 decoder graph.");
+	let replaced = false;
+	const graphParts = fields(graph.body).map((f) => {
+		if (f.number !== 1 || firstString(f.body, 3) !== "/mask_decoder/Add") return f.raw;
+		const inputs = strings(f.body, 1);
+		if (inputs[0] !== "feats2" || inputs[1] !== "/prompt_encoder/Expand_output_0") throw new Error("Unexpected SAM 3 dense prompt contract.");
+		replaced = true;
+		return lengthDelimited(1, concat(fields(f.body).filter((x) => x.number !== 1).map((x) => x.raw).concat([text(1, "feats2"), text(1, "dense_prompt")])));
+	});
+	if (!replaced) throw new Error("SAM 3 decoder has no prompt embedding input.");
+	graphParts.push(lengthDelimited(11, value("dense_prompt", [
+		1,
+		256,
+		72,
+		72
+	])));
+	return concat(modelFields.map((f) => f === graph ? lengthDelimited(7, concat(graphParts)) : f.raw));
+}
+/** Dynamic memory lengths: never duplicate unavailable early-frame memories. */
+var Sam3MemoryBank = class {
+	seed;
+	recent = [];
+	constructor(temporal) {
+		this.temporal = temporal;
+	}
+	remember(memory, prompted) {
+		if (prompted) {
+			this.seed = memory;
+			this.recent = [];
+		} else {
+			this.recent.push(memory);
+			if (this.recent.length > 15) this.recent.shift();
+		}
+	}
+	assemble(frame, frameCount) {
+		if (!this.seed) throw new Error("SAM 3 needs a prompt before propagation.");
+		const blocks = [this.seed, ...this.recent.slice(-6)];
+		const spatial = new Float32Array(blocks.length * 5184 * 64), positions = new Float32Array(spatial.length);
+		for (const [i, block] of blocks.entries()) {
+			spatial.set(block.tokens, i * 5184 * 64);
+			const row = block === this.seed ? 6 : Math.min(5, frame - block.frame - 1);
+			for (let j = 0; j < block.positions.length; j++) positions[i * 5184 * 64 + j] = (block.positions[j] ?? 0) + (this.temporal[row * 64 + j % 64] ?? 0);
+		}
+		const entries = [this.seed, ...[...this.recent].reverse()].slice(0, 16);
+		const pointers = new Float32Array(entries.length * 256), encoding = new Float32Array(16 * 256);
+		for (const [i, entry] of entries.entries()) {
+			pointers.set(entry.pointer, i * 256);
+			const diff = (frame - entry.frame) / Math.max(1, Math.min(frameCount, 16) - 1);
+			for (let j = 0; j < 128; j++) {
+				const angle = diff / 1e4 ** (2 * Math.floor(j / 2) / 128);
+				encoding[i * 256 + j] = Math.sin(angle);
+				encoding[i * 256 + 128 + j] = Math.cos(angle);
+			}
+		}
+		return {
+			spatial,
+			positions,
+			pointers,
+			encoding,
+			pointerCount: entries.length
+		};
+	}
+};
+/** SAM 3 PositionEmbeddingSine: y then x, normalized pixel centers at grid indices 1..72. */
+function sam3Position() {
+	const out = new Float32Array(5184 * 256);
+	for (let y = 0; y < 72; y++) for (let x = 0; x < 72; x++) for (let j = 0; j < 128; j++) {
+		const divisor = 1e4 ** (2 * Math.floor(j / 2) / 128);
+		const yy = (y + 1) / 72.000001 * 2 * Math.PI / divisor, xx = (x + 1) / 72.000001 * 2 * Math.PI / divisor;
+		out[(y * 72 + x) * 256 + j] = j % 2 ? Math.cos(yy) : Math.sin(yy);
+		out[(y * 72 + x) * 256 + 128 + j] = j % 2 ? Math.cos(xx) : Math.sin(xx);
+	}
+	return out;
+}
+function sam3Floats(outputs, name) {
+	const value$1 = outputs[name];
+	if (!(value$1?.data instanceof Float32Array)) throw new Error(`Missing SAM 3 float output ${name}`);
+	return value$1.data;
+}
+async function sam3Run(session, inputs) {
+	if (!session.runMany) throw new Error("SAM 3 requires a session provider with runMany support.");
+	return session.runMany(inputs);
+}
+/** Semantic model is separate from the visual tracker and loads only for text prompts. */
+var Sam3TextSelector = class Sam3TextSelector$1 {
+	sessions = [];
+	encoded;
+	constructor(tokenizer) {
+		this.tokenizer = tokenizer;
+	}
+	static async create(store, provider) {
+		const json = async (key) => JSON.parse(new TextDecoder().decode(await store.ensure(key)));
+		const selector = new Sam3TextSelector$1(new Tokenizer(await json("sam3-tokenizer"), await json("sam3-tokenizer-config")));
+		try {
+			selector.sessions.push(await provider.createSession(await store.ensure("sam3-text-vision_encoder"), { externalData: [{
+				path: "vision_encoder_int4_fp16attn.onnx.data",
+				data: await store.ensure("sam3-text-vision_encoder-data")
+			}] }));
+			for (const key of ["sam3-text-encoder", "sam3-text-decoder"]) selector.sessions.push(await provider.createSession(await store.ensure(key)));
+			return selector;
+		} catch (error) {
+			selector.release();
+			throw error;
+		}
+	}
+	/**
+	* Mask logits (288²) of the instances matching `text` with sigmoid score of at least
+	* `threshold`, best first and at most `max`. Queries that repeat an accepted instance
+	* (mask IoU above 0.5) are skipped. Throws when nothing matches unless `required` is false.
+	*/
+	async select(pixels, text$2, threshold, max = 1, required = true) {
+		const [visionSession, textSession, decoder] = this.sessions;
+		if (!visionSession || !textSession || !decoder) throw new Error("SAM 3 text selector has been released.");
+		const { features, mask } = await this.encodeText(textSession, text$2);
+		const vision = await sam3Run(visionSession, [{
+			name: "pixel_values",
+			data: pixels,
+			dims: [
+				1,
+				3,
+				1008,
+				1008
+			]
+		}]);
+		const inputs = [{
+			name: "text_features",
+			data: features,
+			dims: [
+				1,
+				32,
+				256
+			]
+		}, {
+			name: "attention_mask",
+			data: mask,
+			dims: [1, 32]
+		}];
+		for (const name of [
+			"fpn_hidden_state_0",
+			"fpn_hidden_state_1",
+			"fpn_hidden_state_2",
+			"fpn_position_encoding_2"
+		]) {
+			const value$1 = vision[name];
+			if (!value$1) throw new Error(`Missing SAM 3 concept feature ${name}`);
+			inputs.push({
+				name,
+				data: sam3Floats(vision, name),
+				dims: value$1.dims
+			});
+		}
+		const result = await sam3Run(decoder, inputs), scores = sam3Floats(result, "pred_logits"), masks = sam3Floats(result, "pred_masks");
+		if (masks.length !== scores.length * CELLS) throw new Error("Invalid SAM 3 concept mask shape.");
+		const ranked = [...scores.keys()].sort((a, b) => (scores[b] ?? -Infinity) - (scores[a] ?? -Infinity));
+		const best = 1 / (1 + Math.exp(-(scores[ranked[0] ?? 0] ?? -Infinity)));
+		if (best < threshold && !required) return [];
+		if (best < threshold) throw new Error(`SAM 3 found no confident instance for text ${JSON.stringify(text$2)} (score ${best.toFixed(3)}, threshold ${threshold}).`);
+		const logit = Math.log(threshold / (1 - threshold));
+		const selected = [];
+		for (const query of ranked) {
+			if (selected.length >= max || (scores[query] ?? -Infinity) < logit) break;
+			const candidate = masks.slice(query * CELLS, (query + 1) * CELLS);
+			if (selected.every((kept) => maskIou(kept, candidate) <= .5)) selected.push(candidate);
+		}
+		return selected;
+	}
+	/** Text features for a prompt; the last one is kept, since re-detection repeats it every few frames. */
+	async encodeText(session, text$2) {
+		if (this.encoded?.text === text$2) return this.encoded;
+		const tokens = this.tokenizer.encode(text$2).ids;
+		if (tokens.length > 32) throw new Error("SAM 3 text prompts must fit within 32 CLIP tokens.");
+		const ids = new BigInt64Array(32).fill(49407n), mask = new BigInt64Array(32);
+		tokens.forEach((id, i) => {
+			ids[i] = BigInt(id);
+			mask[i] = 1n;
+		});
+		this.encoded = {
+			text: text$2,
+			features: sam3Floats(await sam3Run(session, [{
+				name: "input_ids",
+				data: ids,
+				dims: [1, 32]
+			}, {
+				name: "attention_mask",
+				data: mask,
+				dims: [1, 32]
+			}]), "text_features").slice(),
+			mask
+		};
+		return this.encoded;
+	}
+	release() {
+		for (const session of this.sessions) session.release();
+		this.sessions.length = 0;
+		this.encoded = void 0;
+	}
+};
+const CELLS = 288 * 288;
+function maskIou(a, b) {
+	let both = 0, either = 0;
+	for (let i = 0; i < a.length; i++) {
+		const x = (a[i] ?? 0) > 0, y = (b[i] ?? 0) > 0;
+		if (x && y) both++;
+		if (x || y) either++;
+	}
+	return either ? both / either : 0;
+}
+/** Frames kept: clips of one source ask for the same frame back to back. */
+const RECENT = 2;
+/**
+* The encoder is most of SAM 3's per-frame cost (3.6 s at fp16 on an M1 Pro), and every
+* clip of a source sees identical pixels. So trackers on one provider and precision share
+* one session and the features of the last frames, keyed by pixel content.
+*/
+var SharedEncoder = class {
+	users = 0;
+	recent = [];
+	constructor(session, forget) {
+		this.session = session;
+		this.forget = forget;
+	}
+	hold() {
+		this.users++;
+		let held = true;
+		return {
+			encode: (image) => this.encode(image),
+			release: () => {
+				if (!held) return;
+				held = false;
+				if (--this.users > 0) return;
+				this.forget();
+				this.recent.length = 0;
+				this.session.release();
+			}
+		};
+	}
+	encode(image) {
+		const key = frameKey(image);
+		const hit = this.recent.find((entry$1) => entry$1.key === key);
+		if (hit) return hit.features;
+		const entry = {
+			key,
+			features: this.run(image)
+		};
+		this.recent.push(entry);
+		if (this.recent.length > RECENT) this.recent.shift();
+		entry.features.catch(() => {
+			const index = this.recent.indexOf(entry);
+			if (index >= 0) this.recent.splice(index, 1);
+		});
+		return entry.features;
+	}
+	async run(image) {
+		const { tensor: pixels } = imageToTensor(image, {
+			width: 1008,
+			height: 1008,
+			fit: "stretch",
+			channels: "rgb",
+			padValue: 0,
+			mean: [
+				127.5,
+				127.5,
+				127.5
+			],
+			std: [
+				127.5,
+				127.5,
+				127.5
+			]
+		});
+		const out = await sam3Run(this.session, [{
+			name: "pixel_values",
+			data: pixels,
+			dims: [
+				1,
+				3,
+				1008,
+				1008
+			]
+		}]);
+		return {
+			pixels,
+			feats0: sam3Floats(out, "image_embeddings.0"),
+			feats1: sam3Floats(out, "image_embeddings.1"),
+			raw: sam3Floats(out, "image_embeddings.2")
+		};
+	}
+};
+const shared = /* @__PURE__ */ new WeakMap();
+/** Holds the process's SAM 3 encoder for `provider` at `precision`, creating it on first use. */
+async function holdSam3Encoder(store, provider, precision) {
+	let byPrecision = shared.get(provider);
+	if (!byPrecision) {
+		byPrecision = /* @__PURE__ */ new Map();
+		shared.set(provider, byPrecision);
+	}
+	const encoders = byPrecision;
+	let encoder$2 = encoders.get(precision);
+	if (!encoder$2) {
+		encoder$2 = (async () => {
+			return new SharedEncoder(await provider.createSession(await store.ensure(`sam3-vision_encoder-${precision}`), { externalData: [{
+				path: sam3EncoderFiles(precision).data,
+				data: await store.ensure(`sam3-vision_encoder-${precision}-data`)
+			}] }), () => encoders.delete(precision));
+		})();
+		encoders.set(precision, encoder$2);
+		encoder$2.catch(() => encoders.delete(precision));
+	}
+	return (await encoder$2).hold();
+}
+/** Content key of a frame: size plus two 32-bit FNV-1a hashes over its bytes. */
+function frameKey(image) {
+	const bytes = image.data;
+	let a = 2166136261, b = 16777619 ^ bytes.length;
+	for (let i = 0; i < bytes.length; i++) {
+		const byte = bytes[i] ?? 0;
+		a = Math.imul(a ^ byte, 16777619);
+		b = Math.imul(b ^ byte, 1540483477) ^ b >>> 15;
+	}
+	return `${image.width}x${image.height}:${(a >>> 0).toString(36)}${(b >>> 0).toString(36)}`;
+}
+/**
+* Text-selected instances as one mask (`sam3.merge`): each pixel keeps its most confident
+* instance's logit, so the union is positive wherever any instance is.
+*/
+function mergeSelections(masks) {
+	const merged = new Float32Array(masks[0]?.length ?? 0).fill(-Infinity);
+	for (const mask of masks) for (let i = 0; i < merged.length; i++) merged[i] = Math.max(merged[i] ?? -Infinity, mask[i] ?? -Infinity);
+	return merged;
+}
+/** Logit SAM uses for a given mask's pixels (and its object score): ±10. */
+const MASK_LOGIT = 10;
+/** A re-detected instance is new while tracked objects cover less than this share of it. */
+const NEW_OBJECT_COVERAGE = .5;
+/** Where any present tracked object is, on the 288² concept grid, as ±10 logits. */
+function coveredCells(tracked) {
+	const covered = new Float32Array(288 * 288).fill(-MASK_LOGIT);
+	for (const { logits, score } of tracked) {
+		if (score <= 0) continue;
+		for (let y = 0; y < 288; y++) {
+			const row = Math.floor((y + .5) * 1008 / 288) * 1008;
+			for (let x = 0; x < 288; x++) if ((logits[row + Math.floor((x + .5) * 1008 / 288)] ?? 0) > 0) covered[y * 288 + x] = MASK_LOGIT;
+		}
+	}
+	return covered;
+}
+/** Re-detected 288² instances that the covered cells do not already hold. */
+function uncovered(found, covered) {
+	return found.filter((instance) => {
+		let inside = 0;
+		let area = 0;
+		for (let i = 0; i < instance.length; i++) {
+			if ((instance[i] ?? 0) <= 0) continue;
+			area++;
+			if ((covered[i] ?? 0) > 0) inside++;
+		}
+		return area > 0 && inside / area < NEW_OBJECT_COVERAGE;
+	});
+}
+/** 1008² seed logits that keep a present tracked mask at full resolution and add `added` to it. */
+function keepTracked(tracked, added) {
+	if (!tracked || tracked.score <= 0) return added;
+	return Float32Array.from(added, (value$1, i) => (tracked.logits[i] ?? 0) > 0 ? MASK_LOGIT : value$1);
+}
+function validateSam3Prompts(options) {
+	const prompts = options.prompts ?? (options.text ? [{
+		frame: 0,
+		text: options.text
+	}] : []);
+	if (!prompts.length) throw new Error("SAM 3 requires at least one prompt or text description.");
+	let previous = -1;
+	for (const prompt of prompts) {
+		if (!Number.isSafeInteger(prompt.frame) || prompt.frame <= previous) throw new Error("SAM 3 prompt frames must be nonnegative, unique and increasing.");
+		previous = prompt.frame;
+		if (prompt.points !== void 0 === (prompt.text !== void 0)) throw new Error("SAM 3 prompts need either points/a box or text.");
+		if (prompt.points) validateSam2Prompts([{
+			frame: prompt.frame,
+			points: prompt.points
+		}]);
+		if (prompt.text !== void 0 && !prompt.text.trim()) throw new Error("SAM 3 text prompts must not be empty.");
+		if (prompt.object !== void 0 && (prompt.text !== void 0 || !Number.isSafeInteger(prompt.object) || prompt.object < 1)) throw new Error("SAM 3 prompt objects are positive track IDs on points prompts.");
+	}
+	const maxObjects = options.maxObjects ?? 1;
+	if (!Number.isSafeInteger(maxObjects) || maxObjects < 1) throw new Error("SAM 3 maxObjects must be a positive integer.");
+	const redetect = options.redetect ?? 0;
+	if (!Number.isSafeInteger(redetect) || redetect < 0) throw new Error("SAM 3 redetect must be a nonnegative integer frame interval.");
+	const threshold = options.textThreshold ?? .5;
+	if (!Number.isFinite(threshold) || threshold <= 0 || threshold >= 1) throw new Error("SAM 3 textThreshold must be between zero and one.");
+}
+/** Every graph and tokenizer revision, and the encoder precision: ClipVision's cache identity. */
+function sam3Revision(precision) {
+	return `sam3-${precision}-429305c8-video-e942689a-support-68ce2746-text-fe8f8e12-v2`;
+}
+/** The encoder precision a tracker on `provider` uses: the override, else the backend's best. */
+async function sam3Precision(provider = createDefaultSessionProvider(), override) {
+	return override ?? SAM3_ENCODER[await sessionCompute(provider)];
+}
+function tensor(name, data, dims) {
+	return {
+		name,
+		data,
+		dims
+	};
+}
+/**
+* Explicitly selected SAM 3 instances with full neural memory propagation on the provider.
+* The image encoder runs once per frame; each object keeps its own memory bank.
+*/
+var Sam3Tracker = class Sam3Tracker$1 {
+	sessions = /* @__PURE__ */ new Map();
+	encoder;
+	position = sam3Position();
+	banks = [];
+	temporal;
+	noMemory;
+	selector;
+	/** The last text prompt and its frame, which re-detection repeats. */
+	text;
+	lastFrame = -1;
+	released = false;
+	constructor(store, provider, options) {
+		this.store = store;
+		this.provider = provider;
+		this.options = options;
+	}
+	static async create(options = {}) {
+		assertSamLicenseAccepted("SAM 3", options);
+		ensureSamModelsRegistered();
+		if (options.frameCount !== void 0 && (!Number.isSafeInteger(options.frameCount) || options.frameCount < 1)) throw new Error("SAM 3 frameCount must be a positive integer.");
+		if (options.textThreshold !== void 0 && (!Number.isFinite(options.textThreshold) || options.textThreshold <= 0 || options.textThreshold >= 1)) throw new Error("SAM 3 textThreshold must be between zero and one.");
+		if (options.maxObjects !== void 0 && (!Number.isSafeInteger(options.maxObjects) || options.maxObjects < 1)) throw new Error("SAM 3 maxObjects must be a positive integer.");
+		if (options.redetect !== void 0 && (!Number.isSafeInteger(options.redetect) || options.redetect < 0)) throw new Error("SAM 3 redetect must be a nonnegative integer frame interval.");
+		const store = options.store ?? new VisionModelStore({
+			...options,
+			acceptLicense: options.acceptLicense ?? true
+		});
+		const provider = options.provider ?? createDefaultSessionProvider();
+		const tracker$1 = new Sam3Tracker$1(store, provider, options);
+		try {
+			tracker$1.encoder = await holdSam3Encoder(store, provider, await sam3Precision(provider, options.precision));
+			const support$1 = sam3SupportGraphs(await store.ensure("sam3-support"), await store.ensure("sam3-support-data"));
+			tracker$1.temporal = support$1.temporal;
+			tracker$1.noMemory = support$1.noMemory;
+			tracker$1.sessions.set("dense_prompt", await provider.createSession(support$1.densePrompt));
+			tracker$1.sessions.set("pointer_position", await provider.createSession(support$1.pointerPosition));
+			const decoder = await store.ensure("sam3-mask_decoder");
+			tracker$1.sessions.set("mask_decoder", await provider.createSession(decoder));
+			tracker$1.sessions.set("dense_decoder", await provider.createSession(sam3DenseDecoder(decoder)));
+			for (const graph of ["memory_encoder", "memory_attention"]) tracker$1.sessions.set(graph, await provider.createSession(await store.ensure(`sam3-${graph}`)));
+			if (!options.store) store.clearMemoryCache();
+			return tracker$1;
+		} catch (error) {
+			tracker$1.release();
+			throw error;
+		}
+	}
+	run(graph, inputs) {
+		const session = this.sessions.get(graph);
+		if (!session) throw new Error("SAM 3 tracker has been released.");
+		return sam3Run(session, inputs);
+	}
+	async process(image, frame, prompt) {
+		if (this.released) throw new Error("SAM 3 tracker has been released.");
+		if (!Number.isSafeInteger(frame) || frame < 0 || this.lastFrame >= 0 && frame !== this.lastFrame + 1) throw new Error("SAM 3 propagation requires consecutive source frames.");
+		if (prompt) validateSam3Prompts({ prompts: [{
+			...prompt,
+			frame
+		}] });
+		if (this.lastFrame < 0 && !prompt) throw new Error("SAM 3 needs a prompt on its first frame.");
+		if (!this.encoder) throw new Error("SAM 3 tracker has been released.");
+		const { pixels, feats0, feats1, raw } = await this.encoder.encode(image);
+		const shared$1 = [tensor("feats0", feats0, [
+			1,
+			32,
+			288,
+			288
+		]), tensor("feats1", feats1, [
+			1,
+			64,
+			144,
+			144
+		])];
+		const seeds = await this.seeds(pixels, frame, prompt);
+		const tracked = [];
+		for (const [index, bank] of this.banks.entries()) {
+			const seed = seeds.get(index);
+			const features = seed ? this.initialFeatures(raw) : await this.condition(raw, frame, bank);
+			tracked.push(this.track(seed, await this.decode(shared$1, features, seed)));
+		}
+		if (!prompt) await this.redetect(pixels, frame, tracked, shared$1, raw);
+		const objects = [];
+		for (const [index, bank] of this.banks.entries()) {
+			const item = tracked[index];
+			if (!item) continue;
+			const { seed, decoded, logits, score } = item;
+			await this.remember(bank, raw, decoded, frame, seed, logits, score);
+			objects.push({
+				id: index + 1,
+				mask: sam3Mask(logits, image.width, image.height, score),
+				score,
+				iou: seed?.mask ? 1 : Math.max(...sam3Floats(decoded, "iou_scores"))
+			});
+		}
+		this.lastFrame = frame;
+		return {
+			width: image.width,
+			height: image.height,
+			objects
+		};
+	}
+	track(seed, decoded) {
+		return {
+			seed,
+			decoded,
+			logits: seed?.mask ?? sam3Floats(decoded, "high_res_masks"),
+			score: seed?.mask ? MASK_LOGIT : sam3Floats(decoded, "object_score_logits")[0] ?? -Infinity
+		};
+	}
+	/**
+	* On a `redetect` frame, runs the last text prompt again and seeds what no tracked object
+	* covers: merged into the one object (keeping what it tracks), or as new objects.
+	*/
+	async redetect(pixels, frame, tracked, shared$1, raw) {
+		const every = this.options.redetect ?? 0;
+		if (!this.text || every <= 0 || (frame - this.text.frame) % every !== 0) return;
+		const room = this.options.merge ? Infinity : (this.options.maxObjects ?? 1) - this.banks.length;
+		if (room <= 0) return;
+		const found = await (await this.textSelector()).select(pixels, this.text.value, this.options.textThreshold ?? .5, Infinity, false);
+		const covered = coveredCells(tracked);
+		const fresh = uncovered(found, covered).slice(0, room);
+		if (!fresh.length) return;
+		const seeded = async (seed) => this.track(seed, await this.decode(shared$1, this.initialFeatures(raw), seed));
+		if (this.options.merge) {
+			const added = mergeSelections(fresh);
+			const kept = tracked[0];
+			if (!kept) this.banks.push(this.newBank());
+			tracked[0] = await seeded({
+				dense: await this.densePrompt(mergeSelections([added, covered])),
+				mask: keepTracked(kept, seedLogits(added))
+			});
+			return;
+		}
+		for (const logits of fresh) {
+			this.banks.push(this.newBank());
+			tracked.push(await seeded(await this.textSeed(logits)));
+		}
+	}
+	async textSelector() {
+		this.selector ??= await Sam3TextSelector.create(this.store, this.provider);
+		if (!this.options.store) this.store.clearMemoryCache();
+		return this.selector;
+	}
+	/** A 288² concept mask as a seed that outputs (and remembers) that mask. */
+	async textSeed(logits) {
+		return {
+			dense: await this.densePrompt(logits),
+			mask: seedLogits(logits)
+		};
+	}
+	async densePrompt(logits) {
+		const binary = Float32Array.from(logits, (v) => v > 0 ? 1 : 0);
+		return sam3Floats(await this.run("dense_prompt", [tensor("mask", binary, [
+			1,
+			1,
+			288,
+			288
+		])]), "dense_prompt");
+	}
+	/** Objects a prompt (re)seeds, by index. Text re-selects every object; points address one. */
+	async seeds(pixels, frame, prompt) {
+		const seeds = /* @__PURE__ */ new Map();
+		if (prompt?.points) {
+			const index = (prompt.object ?? 1) - 1;
+			if (index > this.banks.length) throw new Error(`SAM 3 prompt object ${index + 1} skips track IDs; the next new ID is ${this.banks.length + 1}.`);
+			if (index === this.banks.length) this.banks.push(this.newBank());
+			seeds.set(index, { points: prompt.points });
+		}
+		if (prompt?.text !== void 0) {
+			const selected = await (await this.textSelector()).select(pixels, prompt.text, this.options.textThreshold ?? .5, this.options.maxObjects ?? (this.options.merge ? Infinity : 1));
+			const masks = this.options.merge ? [mergeSelections(selected)] : selected;
+			this.text = {
+				value: prompt.text,
+				frame
+			};
+			this.banks.length = 0;
+			for (const [index, logits] of masks.entries()) {
+				this.banks.push(this.newBank());
+				seeds.set(index, await this.textSeed(logits));
+			}
+		}
+		return seeds;
+	}
+	newBank() {
+		if (!this.temporal) throw new Error("SAM 3 tracker has been released.");
+		return new Sam3MemoryBank(this.temporal);
+	}
+	decode(shared$1, features, seed) {
+		const points = seed?.points ?? [{
+			x: 0,
+			y: 0,
+			label: -1
+		}];
+		const inputs = [
+			...shared$1,
+			tensor("feats2", features, [
+				1,
+				256,
+				72,
+				72
+			]),
+			tensor("input_points", Float32Array.from(points.flatMap((p) => [p.x * 1008, p.y * 1008])), [
+				1,
+				1,
+				points.length,
+				2
+			]),
+			tensor("input_labels", Int32Array.from(points.map((p) => p.label)), [
+				1,
+				1,
+				points.length
+			])
+		];
+		if (!seed?.dense) return this.run("mask_decoder", inputs);
+		return this.run("dense_decoder", [...inputs, tensor("dense_prompt", seed.dense, [
+			1,
+			256,
+			72,
+			72
+		])]);
+	}
+	initialFeatures(raw) {
+		if (!this.noMemory) throw new Error("Missing SAM 3 no-memory embedding.");
+		return Float32Array.from(raw, (value$1, i) => value$1 + (this.noMemory?.[Math.floor(i / 5184)] ?? 0));
+	}
+	async condition(raw, frame, memory) {
+		const bank = memory.assemble(frame, this.options.frameCount ?? 16);
+		const positions = await this.run("pointer_position", [tensor("encoding", bank.encoding, [16, 256])]);
+		const pointerPosition = new Float32Array(bank.pointerCount * 256), projected = sam3Floats(positions, "position");
+		for (let i = 0; i < bank.pointerCount; i++) for (let token = 0; token < 4; token++) pointerPosition.set(projected.subarray(i * 64, (i + 1) * 64), (i * 4 + token) * 64);
+		const tokens = sam3Floats(await this.run("memory_attention", [
+			tensor("current_vision_features", sam2Tokens(raw), [
+				5184,
+				1,
+				256
+			]),
+			tensor("current_vision_position_embeddings", this.position, [
+				5184,
+				1,
+				256
+			]),
+			tensor("spatial_memory", bank.spatial, [
+				bank.spatial.length / 64,
+				1,
+				64
+			]),
+			tensor("spatial_memory_position_embeddings", bank.positions, [
+				bank.positions.length / 64,
+				1,
+				64
+			]),
+			tensor("pointer_memory", bank.pointers, [
+				bank.pointerCount * 4,
+				1,
+				64
+			]),
+			tensor("pointer_memory_position_embeddings", pointerPosition, [
+				bank.pointerCount * 4,
+				1,
+				64
+			])
+		]), "conditioned_features"), nchw = new Float32Array(tokens.length);
+		for (let i = 0; i < 5184; i++) for (let channel = 0; channel < 256; channel++) nchw[channel * 5184 + i] = tokens[i * 256 + channel] ?? 0;
+		return nchw;
+	}
+	async remember(bank, raw, decoded, frame, seed, logits, score) {
+		const memory = await this.run("memory_encoder", [
+			tensor("vision_features", raw, [
+				1,
+				256,
+				72,
+				72
+			]),
+			tensor("pred_masks_high_res", logits, [
+				1,
+				1,
+				1008,
+				1008
+			]),
+			tensor("object_score_logits", Float32Array.of(score), [1, 1]),
+			tensor("is_mask_from_pts", new Uint8Array([seed ? 1 : 0]), [1])
+		]);
+		bank.remember({
+			frame,
+			tokens: sam3Floats(memory, "memory_tokens").slice(),
+			positions: sam3Floats(memory, "memory_pos_enc").slice(),
+			pointer: sam3Floats(decoded, "object_pointer").slice()
+		}, seed !== void 0);
+	}
+	release() {
+		for (const session of this.sessions.values()) session.release();
+		this.sessions.clear();
+		this.encoder?.release();
+		this.encoder = void 0;
+		this.selector?.release();
+		this.banks.length = 0;
+		this.temporal = void 0;
+		this.noMemory = void 0;
+		this.released = true;
+	}
+};
+/** Resize logits before thresholding; source pixels are the public mask coordinate system. */
+function sam3Mask(logits, width, height, score) {
+	if (logits.length !== 1008 * 1008) throw new Error("Invalid SAM 3 high-resolution mask shape.");
+	const mask = new Uint8Array(width * height);
+	if (score <= 0) return mask;
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		const sy = Math.max(0, Math.min(1007, (y + .5) * 1008 / height - .5)), sx = Math.max(0, Math.min(1007, (x + .5) * 1008 / width - .5));
+		const y0 = Math.floor(sy), x0 = Math.floor(sx), fy = sy - y0, fx = sx - x0, y1 = Math.min(1007, y0 + 1), x1 = Math.min(1007, x0 + 1);
+		const top = (logits[y0 * 1008 + x0] ?? 0) * (1 - fx) + (logits[y0 * 1008 + x1] ?? 0) * fx, bottom = (logits[y1 * 1008 + x0] ?? 0) * (1 - fx) + (logits[y1 * 1008 + x1] ?? 0) * fx;
+		mask[y * width + x] = top * (1 - fy) + bottom * fy > 0 ? 255 : 0;
+	}
+	return mask;
+}
+/** A 288² concept mask's logits as SAM's 1008² seed logits: bilinear, then ±10. */
+function seedLogits(logits) {
+	const out = new Float32Array(1008 * 1008);
+	for (let y = 0; y < 1008; y++) {
+		const sy = Math.max(0, Math.min(287, (y + .5) * 288 / 1008 - .5)), y0 = Math.floor(sy), y1 = Math.min(287, y0 + 1), fy = sy - y0;
+		for (let x = 0; x < 1008; x++) {
+			const sx = Math.max(0, Math.min(287, (x + .5) * 288 / 1008 - .5)), x0 = Math.floor(sx), x1 = Math.min(287, x0 + 1), fx = sx - x0;
+			const top = (logits[y0 * 288 + x0] ?? 0) * (1 - fx) + (logits[y0 * 288 + x1] ?? 0) * fx, bottom = (logits[y1 * 288 + x0] ?? 0) * (1 - fx) + (logits[y1 * 288 + x1] ?? 0) * fx;
+			out[y * 1008 + x] = top * (1 - fy) + bottom * fy > 0 ? MASK_LOGIT : -MASK_LOGIT;
+		}
+	}
+	return out;
+}
+
+//#endregion
+export { sam3Run as C, validateSam3Prompts as E, sam3Revision as S, validateSam2Prompts as T, sam3EncoderFiles as _, SAM_MODELS as a, sam3Position as b, Sam3MemoryBank as c, assertSamLicenseAccepted as d, decodeSam2Mask as f, sam3DenseDecoder as g, sam2Tokens as h, SAM_LICENSE_TERMS_URL as i, Sam3TextSelector as l, sam2Revision as m, SAM3_ENCODER as n, Sam2MemoryBank as o, ensureSamModelsRegistered as p, SAM_LICENSE as r, Sam2Tracker as s, SAM2_EXPORTS as t, Sam3Tracker as u, sam3Floats as v, sam3SupportGraphs as w, sam3Precision as x, sam3Mask as y };
+//# sourceMappingURL=dist-Dq5TkNDI.mjs.map