framefields 2.0.2 → 2.0.3

package/dist/renderer-xc9wkiC7.mjs

@@ -0,0 +1,3 @@
+import { t as renderers_default } from "./renderer-z6Qb5Z-W.mjs";
+
+export { renderers_default as default };

package/dist/{renderer-XcmYTd6P.mjs → renderer-z6Qb5Z-W.mjs}

@@ -190,7 +190,7 @@ const COCO_CLASSES = [
 ];
 
 //#endregion
-//#region ../vision/dist/src-DbPyIIat.mjs
+//#region ../vision/dist/src-C2sA_wDT.mjs
 function computeIoU(boxA, boxB) {
 	const xA = Math.max(boxA.originX, boxB.originX);
 	const yA = Math.max(boxA.originY, boxB.originY);
@@ -1474,10 +1474,149 @@ function createNeutralLandmarks() {
 	});
 	return landmarks;
 }
+const ORT_WEB_SPECIFIER = "onnxruntime-web";
+const defaultLoader = () => import(
+	/* @vite-ignore */
+	ORT_WEB_SPECIFIER
+);
+var WebGPUProvider = class {
+	kind = "webgpu";
+	_loader;
+	_providers;
+	_wasmFallback;
+	_ortPromise;
+	constructor(options = {}) {
+		this._loader = options.loader ?? defaultLoader;
+		this._providers = options.executionProviders ?? ["webgpu", "wasm"];
+		this._wasmFallback = options.wasmFallback !== false;
+	}
+	ort() {
+		if (!this._ortPromise) this._ortPromise = this._loader().catch((err) => {
+			this._ortPromise = void 0;
+			throw new Error(`onnxruntime-web failed to load (${String(err)}). Install it in the browser bundle or pass a custom loader.`);
+		});
+		return this._ortPromise;
+	}
+	async createSession(modelBytes) {
+		const ort = await this.ort();
+		let session;
+		try {
+			session = await ort.InferenceSession.create(modelBytes, {
+				executionProviders: [...this._providers],
+				graphOptimizationLevel: "all",
+				logSeverityLevel: 3
+			});
+		} catch (err) {
+			if (!this._wasmFallback || !this._providers.includes("webgpu")) throw err;
+			session = await ort.InferenceSession.create(modelBytes, {
+				executionProviders: ["wasm"],
+				graphOptimizationLevel: "all",
+				logSeverityLevel: 3
+			});
+		}
+		return {
+			run: async (input) => {
+				const inputName = session.inputNames.includes(input.name) ? input.name : session.inputNames[0] ?? input.name;
+				const results = await session.run({ [inputName]: new ort.Tensor("float32", input.data, [...input.dims]) });
+				const outputs = {};
+				for (const [name, tensor] of Object.entries(results)) outputs[name] = {
+					data: tensor.data,
+					dims: [...tensor.dims]
+				};
+				return outputs;
+			},
+			release: () => {
+				session.release();
+			}
+		};
+	}
+};
+const ORT_WEBGPU_SPECIFIER = "onnxruntime-web/webgpu";
+const WEBGPU_SPECIFIER = "webgpu";
+let nodeWebGPUReady;
+/**
+* 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.
+*/
+function ensureNodeWebGPU() {
+	if (!nodeWebGPUReady) {
+		nodeWebGPUReady = (async () => {
+			const g = globalThis;
+			if (g.navigator?.gpu) return;
+			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
+			});
+		})();
+		nodeWebGPUReady.catch(() => {
+			nodeWebGPUReady = void 0;
+		});
+	}
+	return nodeWebGPUReady;
+}
+var NodeWebGPUProvider = class {
+	kind = "webgpu";
+	_inner;
+	constructor(options = {}) {
+		const loader = options.loader ?? (async () => {
+			await ensureNodeWebGPU();
+			const mod = await import(
+				/* @vite-ignore */
+				ORT_WEBGPU_SPECIFIER
+);
+			if (mod.env?.wasm) mod.env.wasm.numThreads = 1;
+			return mod;
+		});
+		this._inner = new WebGPUProvider({
+			wasmFallback: false,
+			...options,
+			loader
+		});
+	}
+	createSession(modelBytes) {
+		return this._inner.createSession(modelBytes);
+	}
+};
 let defaultProvider;
-/** The provider for a runner created without one. */
+/**
+* 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.
+*/
+var AutoSessionProvider = class {
+	_resolved;
+	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();
+			}
+		}
+		return this._resolved.createSession(modelBytes);
+	}
+};
+/**
+* The provider for a runner created without one: GPU if possible, otherwise CPU.
+*/
 function createDefaultSessionProvider() {
-	return defaultProvider?.() ?? new NodeSessionProvider();
+	return defaultProvider?.() ?? new AutoSessionProvider();
 }
 /** onnxruntime-node provider. The native module is imported lazily on first session. */
 var NodeSessionProvider = class {
@@ -3815,4 +3954,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-XcmYTd6P.mjs.map
+//# sourceMappingURL=renderer-z6Qb5Z-W.mjs.map