framefields 2.1.3 → 2.2.0-beta.1

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

@@ -190,7 +190,7 @@ const COCO_CLASSES = [
 ];
 
 //#endregion
-//#region ../vision/dist/src-C2sA_wDT.mjs
+//#region ../vision/dist/src-BjTNynFj.mjs
 function computeIoU(boxA, boxB) {
 	const xA = Math.max(boxA.originX, boxB.originX);
 	const yA = Math.max(boxA.originY, boxB.originY);
@@ -1534,27 +1534,42 @@ var WebGPUProvider = class {
 const ORT_WEBGPU_SPECIFIER = "onnxruntime-web/webgpu";
 const WEBGPU_SPECIFIER = "webgpu";
 let nodeWebGPUReady;
+/** CPU rasterizers (lavapipe, llvmpipe, SwiftShader): slower than the CPU EP. */
+const SOFTWARE_ADAPTER = /llvmpipe|lavapipe|swiftshader|software/i;
 /**
-* Ensure `globalThis.navigator.gpu` exists. In the renderer this is already the
-* Dawn device; otherwise imports the `webgpu` (Dawn) package and installs its
-* globals plus an adapter, which is what onnxruntime-web's WebGPU EP needs.
+* Ensure `globalThis.navigator.gpu` exists and has a hardware adapter that
+* onnxruntime-web's WebGPU EP can use. In the renderer this is already the Dawn
+* device; otherwise imports the `webgpu` (Dawn) package and installs its
+* globals. Rejects when the only adapter is a software rasterizer.
 */
 function ensureNodeWebGPU() {
 	if (!nodeWebGPUReady) {
 		nodeWebGPUReady = (async () => {
 			const g = globalThis;
-			if (g.navigator?.gpu) return;
-			const { create, globals } = await import(
-				/* @vite-ignore */
-				WEBGPU_SPECIFIER
+			if (!g.navigator?.gpu) {
+				const { create, globals } = await import(
+					/* @vite-ignore */
+					WEBGPU_SPECIFIER
 );
-			Object.assign(globalThis, globals);
-			const nav = g.navigator ??= {};
-			Object.defineProperty(nav, "gpu", {
-				value: create([]),
-				configurable: true,
-				writable: true
-			});
+				Object.assign(globalThis, globals);
+				g.navigator ??= {};
+				Object.defineProperty(g.navigator, "gpu", {
+					value: create([]),
+					configurable: true,
+					writable: true
+				});
+			}
+			const adapter = await (g.navigator?.gpu).requestAdapter({ powerPreference: "high-performance" });
+			if (!adapter) throw new Error("No WebGPU adapter.");
+			const info = adapter.info ?? {};
+			const name = [
+				info.vendor,
+				info.architecture,
+				info.device,
+				info.description
+			].filter(Boolean).join(" ");
+			if (adapter.isFallbackAdapter === true || info.isFallbackAdapter === true || SOFTWARE_ADAPTER.test(name)) throw new Error(`WebGPU adapter is a software rasterizer (${name}).`);
+			patchSupportedFeatures(adapter.features);
 		})();
 		nodeWebGPUReady.catch(() => {
 			nodeWebGPUReady = void 0;
@@ -1562,6 +1577,36 @@ function ensureNodeWebGPU() {
 	}
 	return nodeWebGPUReady;
 }
+/**
+* Dawn's Node `GPUSupportedFeatures` has `has`/`keys`/`size` but no `forEach`,
+* which onnxruntime-web's WebGPU build calls on adapter and device features
+* (they share the class). Adds the missing set-like methods once.
+*/
+function patchSupportedFeatures(features) {
+	const proto = Object.getPrototypeOf(features);
+	if (!proto || typeof proto.keys !== "function") return;
+	if (typeof proto.forEach !== "function") Object.defineProperty(proto, "forEach", {
+		value(callback, thisArg) {
+			for (const key of this.keys()) callback.call(thisArg, key, key, this);
+		},
+		configurable: true,
+		writable: true
+	});
+	if (typeof proto.values !== "function") Object.defineProperty(proto, "values", {
+		value() {
+			return this.keys();
+		},
+		configurable: true,
+		writable: true
+	});
+	if (typeof proto.entries !== "function") Object.defineProperty(proto, "entries", {
+		*value() {
+			for (const key of this.keys()) yield [key, key];
+		},
+		configurable: true,
+		writable: true
+	});
+}
 var NodeWebGPUProvider = class {
 	kind = "webgpu";
 	_inner;
@@ -1573,6 +1618,7 @@ var NodeWebGPUProvider = class {
 				ORT_WEBGPU_SPECIFIER
 );
 			if (mod.env?.wasm) mod.env.wasm.numThreads = 1;
+			if (mod.env?.webgpu) mod.env.webgpu.powerPreference = "high-performance";
 			return mod;
 		});
 		this._inner = new WebGPUProvider({
@@ -1586,41 +1632,113 @@ var NodeWebGPUProvider = class {
 	}
 };
 let defaultProvider;
+function requestedVisionBackend() {
+	const value = typeof process !== "undefined" ? process.env.FRAMEFIELDS_VISION_PROVIDER?.trim().toLowerCase() : void 0;
+	return value === "webgpu" || value === "cuda" || value === "cpu" ? value : "auto";
+}
 /**
 * Prefers the GPU (onnxruntime-web's WebGPU EP on the process's WebGPU device —
 * the Dawn device the renderer already creates, or one this ensures) and falls
 * back to the CPU provider (onnxruntime-node) when a WebGPU session cannot be
-* created: no device, no Dawn, or the EP unavailable. The choice is made on the
-* first session and reused for the runner's lifetime.
+* created: no hardware adapter, no Dawn, or onnxruntime-web not installed. The
+* choice is made on the first session and kept.
+*
+* `FRAMEFIELDS_VISION_PROVIDER` forces one backend instead: `webgpu`, `cpu`, or
+* `cuda` (onnxruntime-node's CUDA EP on Linux x64; needs the CUDA 12 and cuDNN 9
+* libraries). A forced backend that fails throws instead of falling back.
 */
 var AutoSessionProvider = class {
 	_resolved;
+	_resolving;
 	get kind() {
 		return this._resolved?.kind ?? "webgpu";
 	}
 	async createSession(modelBytes) {
-		if (!this._resolved) {
-			const webgpu = new NodeWebGPUProvider({ wasmFallback: false });
-			try {
-				const session = await webgpu.createSession(modelBytes);
-				this._resolved = webgpu;
-				return session;
-			} catch {
-				this._resolved = new NodeSessionProvider();
-			}
+		if (this._resolved) return this._resolved.createSession(modelBytes);
+		if (!this._resolving) {
+			this._resolving = this.resolve(modelBytes);
+			this._resolving.catch(() => {
+				this._resolving = void 0;
+			});
+			const { provider: provider$1, first } = await this._resolving;
+			this._resolved = provider$1;
+			if (first) return first;
+			return provider$1.createSession(modelBytes);
+		}
+		const { provider } = await this._resolving;
+		return provider.createSession(modelBytes);
+	}
+	async resolve(modelBytes) {
+		const backend = requestedVisionBackend();
+		if (backend === "cpu") return { provider: new NodeSessionProvider() };
+		if (backend === "cuda") return { provider: new NodeSessionProvider({ executionProviders: ["cuda", "cpu"] }) };
+		const webgpu = new NodeWebGPUProvider({ wasmFallback: false });
+		try {
+			return {
+				provider: webgpu,
+				first: await webgpu.createSession(modelBytes)
+			};
+		} catch (err) {
+			if (backend === "webgpu") throw err;
+			return { provider: new NodeSessionProvider() };
 		}
-		return this._resolved.createSession(modelBytes);
 	}
 };
+let processProvider;
 /**
 * The provider for a runner created without one: GPU if possible, otherwise CPU.
+* One per process, so the GPU probe runs once however many runners there are.
 */
 function createDefaultSessionProvider() {
-	return defaultProvider?.() ?? new AutoSessionProvider();
+	if (defaultProvider) return defaultProvider();
+	processProvider ??= new AutoSessionProvider();
+	return processProvider;
+}
+/**
+* CPUs this process may use: the affinity mask, capped by a cgroup CPU quota
+* (containers). ONNX Runtime sizes its thread pool from the host's cores, which
+* oversubscribes a container limited to fewer CPUs than the host has.
+*/
+async function availableCpus() {
+	const os$1 = await import("node:os");
+	const cpus = typeof os$1.availableParallelism === "function" ? os$1.availableParallelism() : os$1.cpus().length;
+	const quota = await cgroupCpuQuota();
+	return Math.max(1, quota !== void 0 ? Math.min(cpus, quota) : cpus);
+}
+/** cgroup v2 `cpu.max` or v1 `cpu.cfs_quota_us`, in CPUs (rounded up); undefined when unlimited. */
+async function cgroupCpuQuota() {
+	if (typeof process === "undefined" || process.platform !== "linux") return;
+	const { readFile: readFile$1 } = await import("node:fs/promises");
+	const read = (path$1) => readFile$1(path$1, "utf8").then((text) => text.trim(), () => void 0);
+	const toCpus = (quota, period) => quota > 0 && period > 0 ? Math.ceil(quota / period) : void 0;
+	const v2 = await read("/sys/fs/cgroup/cpu.max");
+	if (v2 !== void 0) {
+		const [quota, period] = v2.split(/\s+/);
+		return quota === "max" ? void 0 : toCpus(Number(quota), Number(period));
+	}
+	const v1Quota = await read("/sys/fs/cgroup/cpu/cpu.cfs_quota_us");
+	const v1Period = await read("/sys/fs/cgroup/cpu/cpu.cfs_period_us");
+	if (v1Quota === void 0 || v1Period === void 0) return void 0;
+	return toCpus(Number(v1Quota), Number(v1Period));
+}
+/**
+* Intra-op threads for CPU sessions: `FRAMEFIELDS_VISION_THREADS` when set,
+* else the available CPUs on Linux (where containers cap them), else ONNX
+* Runtime's own default (undefined).
+*/
+async function cpuSessionThreads() {
+	const env = typeof process !== "undefined" ? Number.parseInt(process.env.FRAMEFIELDS_VISION_THREADS ?? "", 10) : NaN;
+	if (Number.isFinite(env) && env > 0) return env;
+	if (typeof process === "undefined" || process.platform !== "linux") return;
+	return availableCpus();
 }
 /** onnxruntime-node provider. The native module is imported lazily on first session. */
 var NodeSessionProvider = class {
 	kind = "node";
+	_executionProviders;
+	constructor(options = {}) {
+		this._executionProviders = options.executionProviders ?? ["cpu"];
+	}
 	ortPromise;
 	async ort() {
 		if (!this.ortPromise) this.ortPromise = import("onnxruntime-node").catch((err) => {
@@ -1631,9 +1749,14 @@ var NodeSessionProvider = class {
 	}
 	async createSession(modelBytes) {
 		const ort = await this.ort();
+		const threads = await cpuSessionThreads();
 		const session = await ort.InferenceSession.create(modelBytes, {
-			executionProviders: ["cpu"],
-			graphOptimizationLevel: "all"
+			executionProviders: [...this._executionProviders],
+			graphOptimizationLevel: "all",
+			...threads !== void 0 ? {
+				intraOpNumThreads: threads,
+				interOpNumThreads: 1
+			} : {}
 		});
 		return {
 			run: async (input) => {
@@ -1652,6 +1775,7 @@ var NodeSessionProvider = class {
 		};
 	}
 };
+const MAX_INSTANCE_PASSES = 4;
 /**
 * Lazy vision runner.
 *
@@ -1666,38 +1790,57 @@ var VisionRunner = class VisionRunner$1 {
 	classes;
 	maskThreshold;
 	featherRadius;
-	_store;
-	_provider;
-	_sessions = /* @__PURE__ */ new Map();
-	_tensorScratch = /* @__PURE__ */ new Map();
-	/** One RTMDet-Ins pass per frame buffer, shared by detect() and segment(). */
-	_instancePass;
-	constructor(options) {
+	_core;
+	/** False for derived runners: their sessions belong to the runner they came from. */
+	_ownsCore;
+	constructor(options, core) {
 		this.variant = options.variant ?? "s";
 		this.confidence = options.confidence ?? .3;
 		this.classes = options.classes;
 		this.maskThreshold = options.maskThreshold ?? .5;
 		this.featherRadius = options.featherRadius;
-		this._store = options.store ?? new VisionModelStore({
-			modelsDir: options.modelsDir,
-			baseUrl: options.baseUrl,
-			timeoutMs: options.timeoutMs,
-			onProgress: options.onProgress
-		});
-		this._provider = options.provider ?? createDefaultSessionProvider();
+		this._ownsCore = core === void 0;
+		this._core = core ?? {
+			store: options.store ?? new VisionModelStore({
+				modelsDir: options.modelsDir,
+				baseUrl: options.baseUrl,
+				timeoutMs: options.timeoutMs,
+				onProgress: options.onProgress
+			}),
+			provider: options.provider ?? createDefaultSessionProvider(),
+			sessions: /* @__PURE__ */ new Map(),
+			tensorScratch: /* @__PURE__ */ new Map(),
+			runQueue: /* @__PURE__ */ new Map(),
+			instancePasses: []
+		};
 	}
 	/** Cheap: no downloads, no sessions, no side effects. */
 	static create(options = {}) {
 		return new VisionRunner$1(options);
 	}
+	/**
+	* A runner with other decode options (confidence, classes, mask threshold,
+	* feather) that shares this runner's models, sessions and per-frame RTMDet-Ins
+	* pass — e.g. one per layer, without loading a model twice. Its `close()` is a
+	* no-op; closing this runner releases the shared sessions.
+	*/
+	derive(options) {
+		return new VisionRunner$1({
+			variant: this.variant,
+			confidence: options.confidence ?? this.confidence,
+			classes: "classes" in options ? options.classes : this.classes,
+			maskThreshold: options.maskThreshold ?? this.maskThreshold,
+			featherRadius: "featherRadius" in options ? options.featherRadius : this.featherRadius
+		}, this._core);
+	}
 	get modelsDir() {
-		return this._store.modelsDir;
+		return this._core.store.modelsDir;
 	}
 	/** Every registry model keyed to its current download state (downloaded → "ready"). */
 	get downloadStatus() {
 		const statuses = /* @__PURE__ */ new Map();
 		for (const key of Object.keys(VISION_MODELS)) statuses.set(key, "pending");
-		for (const [key, status] of this._store.statuses()) statuses.set(key, status);
+		for (const [key, status] of this._core.store.statuses()) statuses.set(key, status);
 		return statuses;
 	}
 	/** The model serving `task` (matte depends on frame aspect; defaults to square). */
@@ -1714,7 +1857,7 @@ var VisionRunner = class VisionRunner$1 {
 			keys.add("selfie-square");
 			keys.add("selfie-landscape");
 		} else keys.add(this.modelKeyFor(task));
-		await this._store.preload([...keys]);
+		await this._core.store.preload([...keys]);
 		await Promise.all([...keys].map((key) => this.session(key)));
 	}
 	/** COCO-80 boxes (sorted by score, source pixels). Masks are not decoded. */
@@ -1761,13 +1904,19 @@ var VisionRunner = class VisionRunner$1 {
 		});
 	}
 	close() {
-		for (const promise of this._sessions.values()) promise.then((session) => session.release()).catch(() => void 0);
-		this._sessions.clear();
-		this._instancePass = void 0;
-		this._store.clearMemoryCache();
+		if (!this._ownsCore) return;
+		const core = this._core;
+		for (const promise of core.sessions.values()) promise.then((session) => session.release()).catch(() => void 0);
+		core.sessions.clear();
+		core.runQueue.clear();
+		core.instancePasses.length = 0;
+		core.store.clearMemoryCache();
 	}
 	instancePass(image) {
-		if (this._instancePass?.frame === image.data) return this._instancePass.result;
+		const passes = this._core.instancePasses;
+		const content = contentKey(image);
+		const byContent = passes.find((pass$1) => pass$1.content === content);
+		if (byContent) return byContent.result;
 		const key = this.modelKeyFor("segment");
 		const result = this.infer(key, image).then(({ outputs, transform }) => {
 			const dets = output(outputs, "dets", key);
@@ -1784,12 +1933,15 @@ var VisionRunner = class VisionRunner$1 {
 				}
 			};
 		});
-		this._instancePass = {
-			frame: image.data,
+		const pass = {
+			content,
 			result
 		};
+		passes.push(pass);
+		if (passes.length > MAX_INSTANCE_PASSES) passes.shift();
 		result.catch(() => {
-			if (this._instancePass?.result === result) this._instancePass = void 0;
+			const index = passes.indexOf(pass);
+			if (index >= 0) passes.splice(index, 1);
 		});
 		return result;
 	}
@@ -1805,15 +1957,30 @@ var VisionRunner = class VisionRunner$1 {
 			...this.featherRadius !== void 0 ? { featherRadius: this.featherRadius } : {}
 		};
 	}
-	async infer(key, image) {
+	/**
+	* Runs one model on one image. Runs of the same model are queued: they share
+	* the input scratch buffer, and one run already uses the session's threads.
+	*/
+	infer(key, image) {
+		const queue = this._core.runQueue;
+		const run = (queue.get(key) ?? Promise.resolve()).then(() => this.inferNow(key, image), () => this.inferNow(key, image));
+		const tail = run.catch(() => void 0);
+		queue.set(key, tail);
+		tail.then(() => {
+			if (queue.get(key) === tail) queue.delete(key);
+		});
+		return run;
+	}
+	async inferNow(key, image) {
 		const session = await this.session(key);
 		const desc = VISION_MODELS[key];
 		const spec = preprocessSpec(desc.family, desc.input);
 		const size = 3 * spec.width * spec.height;
-		let scratch = this._tensorScratch.get(key);
+		const scratchByKey = this._core.tensorScratch;
+		let scratch = scratchByKey.get(key);
 		if (!scratch || scratch.length < size) {
 			scratch = new Float32Array(size);
-			this._tensorScratch.set(key, scratch);
+			scratchByKey.set(key, scratch);
 		}
 		const { tensor, transform } = imageToTensor(image, spec, scratch);
 		return {
@@ -1831,18 +1998,34 @@ var VisionRunner = class VisionRunner$1 {
 		};
 	}
 	session(key) {
-		let promise = this._sessions.get(key);
+		const { sessions, store, provider } = this._core;
+		let promise = sessions.get(key);
 		if (!promise) {
-			promise = this._store.ensure(key).then((bytes) => this._provider.createSession(bytes)).catch((err) => {
-				this._sessions.delete(key);
-				this._store.evict(key);
+			promise = store.ensure(key).then((bytes) => provider.createSession(bytes)).catch((err) => {
+				sessions.delete(key);
+				store.evict(key);
 				throw err;
 			});
-			this._sessions.set(key, promise);
+			sessions.set(key, promise);
 		}
 		return promise;
 	}
 };
+/** Size plus a 64-bit hash of the pixels: equal keys mean the same picture. */
+function contentKey(image) {
+	const { data } = image;
+	const words = data.byteOffset % 4 === 0 ? data.byteLength >>> 2 : 0;
+	const view = new Uint32Array(data.buffer, data.byteOffset, words);
+	let h1 = 2166136261;
+	let h2 = 16777619 ^ data.byteLength;
+	for (let i = 0; i < words; i++) {
+		const v = view[i];
+		h1 = Math.imul(h1 ^ v, 2654435761);
+		h2 = Math.imul(h2 ^ v, 2246822519) ^ h1 >>> 15;
+	}
+	for (let i = words * 4; i < data.length; i++) h1 = Math.imul(h1 ^ data[i], 2654435761);
+	return `${image.width}x${image.height}:${(h1 >>> 0).toString(36)}:${(h2 >>> 0).toString(36)}`;
+}
 function output(outputs, name, key) {
 	const tensor = outputs[name];
 	if (!tensor) throw new Error(`Vision model '${key}' returned no '${name}' output (got: ${Object.keys(outputs).join(", ") || "none"}). Expected the ${VISION_MODELS[key].source}.`);
@@ -3014,7 +3197,7 @@ var VisionNode = class VisionNode$1 {
 };
 
 //#endregion
-//#region ../../nodes/node-vision/dist/renderers-ClCaeCNB.mjs
+//#region ../../nodes/node-vision/dist/renderers-BcBWZ-Rc.mjs
 let scratchValues = new Uint8Array(0);
 let scratchLengths = new Uint32Array(0);
 function encodeMask(mask, width, height) {
@@ -3287,7 +3470,13 @@ var MatteCompositor = class {
 		pass.end();
 	}
 };
-let sharedRunner = null;
+/**
+* Runners by model options (variant, models dir, mirror), each with the runners
+* derived from it by decode options — layers that differ only in classes or
+* confidence share sessions instead of reloading the models.
+*/
+const sharedRunners = /* @__PURE__ */ new Map();
+const MAX_SHARED_RUNNERS = 4;
 let sharedSkeletonRenderer = null;
 let sharedCompositor = null;
 let sharedCompositorFormat = null;
@@ -3384,27 +3573,42 @@ function selectSubject(selected, nodeKey, frame) {
 /**
 * Lazy shared runner — `create()` is a pure constructor (zero I/O); the first frame that
 * requests a task triggers that task's model download at inference time (never at init).
-* Recreated only when an option that changes inference changes.
+* Nodes with the same model options share sessions; decode options (classes,
+* confidence, …) get a derived runner over the same sessions.
 */
 function getSharedRunner(op) {
-	const options = {
+	const modelOptions = {
 		variant: op.variant,
-		confidence: op.confidence,
-		classes: op.classes,
-		maskThreshold: op.maskThreshold,
-		featherRadius: op.featherRadius,
 		modelsDir: op.modelsDir,
 		baseUrl: op.baseUrl
 	};
-	const key = JSON.stringify(options);
-	if (sharedRunner?.key !== key) {
-		sharedRunner?.runner.close();
-		sharedRunner = {
-			key,
-			runner: VisionRunner.create(options)
+	const modelKey = JSON.stringify(modelOptions);
+	let entry = sharedRunners.get(modelKey);
+	if (!entry) {
+		if (sharedRunners.size >= MAX_SHARED_RUNNERS) {
+			const [oldestKey, oldest] = sharedRunners.entries().next().value;
+			oldest.runner.close();
+			sharedRunners.delete(oldestKey);
+		}
+		entry = {
+			runner: VisionRunner.create(modelOptions),
+			derived: /* @__PURE__ */ new Map()
 		};
+		sharedRunners.set(modelKey, entry);
+	}
+	const decodeOptions = {
+		confidence: op.confidence,
+		classes: op.classes,
+		maskThreshold: op.maskThreshold,
+		featherRadius: op.featherRadius
+	};
+	const decodeKey = JSON.stringify(decodeOptions);
+	let runner = entry.derived.get(decodeKey);
+	if (!runner) {
+		runner = entry.runner.derive(decodeOptions);
+		entry.derived.set(decodeKey, runner);
 	}
-	return sharedRunner.runner;
+	return runner;
 }
 function getObjectTracker(nodeKey, op) {
 	let tracker = objectTrackers.get(nodeKey);
@@ -3955,4 +4159,4 @@ var renderers_default = defineRenderer({ WebGPURenderer: VisionWebGPURenderer })
 
 //#endregion
 export { PoseSkeletonRenderer as a, TemporalObjectTracker as c, VisionRunner as d, analyzeSequence as f, COCO_CLASSES as h, COCO17_KEYPOINT_NAMES as i, VisionBundle as l, pinNodeToObject as m, COCO17_BONES as n, SegmentationTexturePool as o, pinNodeToLandmark as p, COCO17_KEYPOINTS as r, SpatialLandmarkTransformer as s, renderers_default as t, VisionNode as u };
-//# sourceMappingURL=renderer-mp1NN5zk.mjs.map
+//# sourceMappingURL=renderer-dc39dBVA.mjs.map