@camstack/addon-model-studio 1.1.32 → 1.1.33

package/dist/model-studio.addon.mjs

@@ -18791,6 +18791,12 @@ var CameraStatusSchema = object({
 	/** Unix timestamp (ms) when this snapshot was composed server-side. */
 	fetchedAt: number()
 });
+var InferenceDeviceExclusionReasonSchema = _enum([
+	"disabled",
+	"unavailable",
+	"cannot-host-camera-root",
+	"accelerator-preferred"
+]);
 var NodeInferenceDeviceSchema = object({
 	/** Stable per-node device key, e.g. `openvino:npu`, `edgetpu:usb`, `cpu`. */
 	key: string(),
@@ -18821,7 +18827,17 @@ var NodeInferenceDeviceSchema = object({
 	* available per format; this is the stored selection that becomes the
 	* default for EVERY camera landing on this accelerator.
 	*/
-	steps: record(string(), DeviceStepConfigSchema).optional()
+	steps: record(string(), DeviceStepConfigSchema).optional(),
+	/**
+	* `null` when the device IS a camera-root candidate on this node; otherwise
+	* the reason the dispatcher drops it. Computed by the SAME
+	* `resolveInferenceDeviceEligibility` the dispatcher runs, so this view can
+	* never disagree with the election — deriving it in the UI from
+	* `enabled`/`available` would silently miss `cannot-host-camera-root` (needs
+	* the node's model catalog) and `accelerator-preferred` (needs the node-wide
+	* "an accelerator is serving" predicate).
+	*/
+	exclusion: InferenceDeviceExclusionReasonSchema.nullable()
 });
 var NodeInferenceDevicesSchema = object({
 	nodeId: string(),
@@ -22579,7 +22595,12 @@ var ListResultSchema = object({
 	probedAt: number()
 });
 var PreferredSchema = LocalInterfaceSchema.nullable();
-var GetConnectionEndpointsResultSchema = object({ endpoints: array(object({
+/**
+* Candidate base URL for the SDK to race on connect. Order matters —
+* the SDK should attempt these top-to-bottom with a short per-candidate
+* timeout (e.g. 1500ms) and cache the winner for the session.
+*/
+var ConnectionEndpointSchema = object({
 	/** Operator-facing label (e.g. "LAN — en0", "Public tunnel"). */
 	label: string(),
 	/** Fully-formed base URL with scheme + host + port. */
@@ -22622,7 +22643,42 @@ var GetConnectionEndpointsResultSchema = object({ endpoints: array(object({
 	* ordering between polls.
 	*/
 	priority: number()
-})).readonly() });
+});
+/**
+* Where the advertised local port came from. Ordered most → least
+* authoritative, and the whole point of returning it: a client must be able to
+* tell a FACT about the hub's socket from an echo of its own guess.
+*/
+var LocalPortSourceEnum = _enum([
+	"server-config",
+	"server-env",
+	"caller-hint",
+	"default"
+]);
+/** The port every LAN/loopback `baseUrl` in the same result was built with. */
+var AdvertisedLocalPortSchema = object({
+	port: number().int().min(1).max(65535),
+	source: LocalPortSourceEnum
+});
+var GetConnectionEndpointsResultSchema = object({
+	endpoints: array(ConnectionEndpointSchema).readonly(),
+	/**
+	* The port the hub built the LAN/loopback URLs with, and where that number
+	* came from.
+	*
+	* Returned rather than merely applied, because "the URL is right" and "the
+	* client can KNOW the URL is right" are different properties. A client that
+	* only sees a corrected URL cannot distinguish a hub that fixed the port from
+	* a hub that echoed the port the client sent, so it cannot decide whether to
+	* race the candidate or discard it. With `source` it can: anything but
+	* `caller-hint` is the hub's own socket.
+	*
+	* Absent on hubs predating this field — a client that finds it missing is
+	* talking to an echoing hub and must degrade exactly as it does for
+	* `caller-hint`.
+	*/
+	localPort: AdvertisedLocalPortSchema
+});
 /**
 * The chosen outbound endpoint for notification artifacts. `baseUrl: null` =
 * AUTO (resolved from the candidate ranking at send time); `resolved` reports
@@ -22643,8 +22699,13 @@ var AllowedAddressesSchema = object({
 */
 addresses: array(string()).readonly() });
 method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(object({
-	/** Local hub HTTP port to use in base URLs. */
-	port: number().int().min(1).max(65535),
+	/**
+	* LEGACY HINT — do not send from new code. Kept optional so clients
+	* written against the echoing contract keep working; the hub uses it
+	* only when it cannot read its own port, and says so via
+	* `localPort.source === 'caller-hint'`.
+	*/
+	port: number().int().min(1).max(65535).optional(),
 	/** Include `http(s)://127.0.0.1:<port>` as the lowest-priority
 	*  candidate. Default `true`. */
 	includeLoopback: boolean().optional(),
@@ -34144,6 +34205,383 @@ function removeCustomModel(list, modelId) {
 		removed: next.length !== list.length
 	};
 }
+var FRIGATE_PUBLIC_CATALOG = [{
+	id: "frigate-mobiledet-edgetpu",
+	label: "Frigate default — SSDLite MobileDet (EdgeTPU)",
+	format: "tflite",
+	url: "https://github.com/google-coral/test_data/raw/release-frogfish/ssdlite_mobiledet_coco_qat_postprocess_edgetpu.tflite",
+	sizeMB: 5.4,
+	inputSize: 320,
+	postprocessor: "ssd",
+	labels: [
+		"person",
+		"bicycle",
+		"car",
+		"motorcycle",
+		"airplane",
+		"bus",
+		"train",
+		"car",
+		"boat",
+		"traffic light",
+		"fire hydrant",
+		"street sign",
+		"stop sign",
+		"parking meter",
+		"bench",
+		"bird",
+		"cat",
+		"dog",
+		"horse",
+		"sheep",
+		"cow",
+		"elephant",
+		"bear",
+		"zebra",
+		"giraffe",
+		"hat",
+		"backpack",
+		"umbrella",
+		"shoe",
+		"eye glasses",
+		"handbag",
+		"tie",
+		"suitcase",
+		"frisbee",
+		"skis",
+		"snowboard",
+		"sports ball",
+		"kite",
+		"baseball bat",
+		"baseball glove",
+		"skateboard",
+		"surfboard",
+		"tennis racket",
+		"bottle",
+		"plate",
+		"wine glass",
+		"cup",
+		"fork",
+		"knife",
+		"spoon",
+		"bowl",
+		"banana",
+		"apple",
+		"sandwich",
+		"orange",
+		"broccoli",
+		"carrot",
+		"hot dog",
+		"pizza",
+		"donut",
+		"cake",
+		"chair",
+		"couch",
+		"potted plant",
+		"bed",
+		"mirror",
+		"dining table",
+		"window",
+		"desk",
+		"toilet",
+		"door",
+		"tv",
+		"laptop",
+		"mouse",
+		"remote",
+		"keyboard",
+		"cell phone",
+		"microwave",
+		"oven",
+		"toaster",
+		"sink",
+		"refrigerator",
+		"blender",
+		"book",
+		"clock",
+		"vase",
+		"scissors",
+		"teddy bear",
+		"hair drier",
+		"toothbrush",
+		"hair brush"
+	],
+	notes: "Frigate's default detection model (the one a stock Frigate + Coral install runs). EdgeTPU-compiled full-integer TFLite, 320×320, TFLite_Detection_PostProcess output → ssd decode. Requires a Coral (tflite format) node."
+}];
+/**
+* Build the registrable descriptor for a curated catalog entry. The URL is
+* the PUBLIC one — any node downloads it on demand; no Distribute needed.
+*/
+function buildFrigateCatalogDescriptor(catalogId, overrides) {
+	const cat = FRIGATE_PUBLIC_CATALOG.find((e) => e.id === catalogId);
+	if (!cat) throw new Error(`Unknown Frigate catalog id "${catalogId}" — available: ${FRIGATE_PUBLIC_CATALOG.map((e) => e.id).join(", ")}`);
+	return {
+		stepId: "object-detection",
+		entry: {
+			id: overrides?.modelId?.trim() || cat.id,
+			name: overrides?.name?.trim() || cat.label,
+			description: `${cat.notes} Imported from the Frigate public catalog via Model Studio.`,
+			formats: { [cat.format]: {
+				url: cat.url,
+				sizeMB: cat.sizeMB,
+				runtimes: ["python"]
+			} },
+			inputSize: {
+				width: cat.inputSize,
+				height: cat.inputSize
+			},
+			labels: cat.labels.map((name) => ({
+				id: name,
+				name
+			})),
+			preprocessMode: "letterbox",
+			...cat.postprocessor !== void 0 ? { postprocessor: cat.postprocessor } : {}
+		}
+	};
+}
+//#endregion
+//#region src/frigate/plus-conversion.ts
+/** Converted formats ADD to the imported entry; identity fields (decode,
+*  labels, description, preprocess) stay the import's. */
+function mergeConvertedFormats(base, converted) {
+	return {
+		...base,
+		formats: {
+			...base.formats,
+			...converted.formats
+		}
+	};
+}
+function targetOf(format) {
+	return format === "openvino" ? {
+		format,
+		precisions: ["fp16"]
+	} : { format };
+}
+/**
+* Convert the imported ONNX for each requested engine, one target at a time,
+* merging every success into the registered entry. Returns one outcome per
+* requested format — the caller surfaces them verbatim.
+*/
+async function runPlusConversions(deps, args) {
+	const outcomes = [];
+	let current = args.entry;
+	for (const format of args.targetFormats) {
+		const targets = [targetOf(format)];
+		try {
+			const ranked = await deps.recommend({ targets });
+			const best = ranked.find((r) => r.supported);
+			if (!best) {
+				const reason = ranked[0]?.reason ?? "no node can satisfy this target";
+				outcomes.push({
+					format,
+					ok: false,
+					error: reason
+				});
+				continue;
+			}
+			const sourceUrl = await deps.freshSourceUrl();
+			const result = await deps.convert({
+				sourceUrl,
+				metadata: {
+					id: current.id,
+					name: current.name,
+					labels: current.labels,
+					inputSize: current.inputSize,
+					preprocessMode: current.preprocessMode ?? "letterbox",
+					outputFormat: "yolo"
+				},
+				targets
+			}, best.nodeId);
+			if (result.artifacts.length === 0) {
+				outcomes.push({
+					format,
+					ok: false,
+					nodeId: best.nodeId,
+					error: "no validated artifacts"
+				});
+				continue;
+			}
+			current = mergeConvertedFormats(current, result.entry);
+			await deps.upsertEntry(current);
+			await deps.markAvailable(best.nodeId, current.id, result.artifacts);
+			outcomes.push({
+				format,
+				ok: true,
+				nodeId: best.nodeId
+			});
+		} catch (err) {
+			outcomes.push({
+				format,
+				ok: false,
+				error: err instanceof Error ? err.message : "conversion failed"
+			});
+		}
+	}
+	return outcomes;
+}
+//#endregion
+//#region src/frigate/frigate-plus.ts
+var PLUS_API_HOST = "https://api.frigate.video";
+var PLUS_KEY_RE = /^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}:[a-z0-9]{40}$/;
+function isValidPlusApiKey(key) {
+	return PLUS_KEY_RE.test(key);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Exchange the API key for an access token. The key never appears in errors. */
+async function fetchPlusAccessToken(fetchFn, apiKey) {
+	if (!isValidPlusApiKey(apiKey)) throw new Error("Frigate+ API key is malformed — expected the \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx:40-hex\" shape shown in your Frigate+ account settings");
+	const [user, pass] = apiKey.split(":");
+	const basic = Buffer.from(`${user}:${pass}`).toString("base64");
+	const res = await fetchFn(`${PLUS_API_HOST}/v1/auth/token`, { headers: { authorization: `Basic ${basic}` } });
+	if (!res.ok) throw new Error(`Frigate+ authentication failed (HTTP ${res.status}) — check the API key in the Model Studio addon settings`);
+	const body = await res.json();
+	const token = isRecord(body) && typeof body.accessToken === "string" ? body.accessToken : null;
+	if (token === null) throw new Error("Frigate+ auth response carried no accessToken");
+	return token;
+}
+async function plusGet(fetchFn, token, path) {
+	const res = await fetchFn(`${PLUS_API_HOST}/v1/${path}`, { headers: { authorization: `Bearer ${token}` } });
+	if (!res.ok) throw new Error(`Frigate+ request "${path}" failed (HTTP ${res.status}): ${await res.text()}`);
+	return res.json();
+}
+/**
+* `verifiedCounts` has THREE real shapes and none may break the parse:
+*   -1                                → base model ("not applicable") ⇒ 0
+*   { "11": 199 }                     → legacy custom (flat label→count)
+*   { camera: { label: n, … }, … }    → recent custom (per camera)
+*/
+function verifiedImageCount(raw) {
+	if (typeof raw === "number") return raw > 0 ? raw : 0;
+	if (!isRecord(raw)) return 0;
+	let total = 0;
+	for (const value of Object.values(raw)) if (typeof value === "number") total += value > 0 ? value : 0;
+	else if (isRecord(value)) {
+		for (const inner of Object.values(value)) if (typeof inner === "number" && inner > 0) total += inner;
+	}
+	return total;
+}
+function toModelSummary(m) {
+	if (typeof m.id !== "string") return null;
+	return {
+		id: m.id,
+		name: typeof m.name === "string" ? m.name : m.id,
+		type: typeof m.type === "string" ? m.type : "unknown",
+		isBaseModel: m.isBaseModel === true,
+		baseModel: typeof m.baseModel === "string" ? m.baseModel : "",
+		supportedDetectors: Array.isArray(m.supportedDetectors) ? m.supportedDetectors.filter((d) => typeof d === "string") : [],
+		trainDate: typeof m.trainDate === "string" ? m.trainDate : "",
+		...typeof m.hailoDevice === "string" ? { hailoDevice: m.hailoDevice } : {},
+		verifiedImages: verifiedImageCount(m.verifiedCounts),
+		...typeof m.width === "number" ? { width: m.width } : {},
+		...typeof m.height === "number" ? { height: m.height } : {}
+	};
+}
+/** Parse a raw `/v1/model/list` body (`{list:[…]}`, or a bare array). */
+function toPlusModelSummaries(raw) {
+	return (Array.isArray(raw) ? raw : isRecord(raw) && Array.isArray(raw.list) ? raw.list : []).filter(isRecord).map(toModelSummary).filter((m) => m !== null);
+}
+/**
+* EVERYTHING the account has access to — base AND custom models. The real
+* response wraps the array: `{ "list": [...] }` (a bare array is tolerated
+* for forward compatibility).
+*/
+async function listPlusModels(fetchFn, apiKey) {
+	return toPlusModelSummaries(await plusGet(fetchFn, await fetchPlusAccessToken(fetchFn, apiKey), "model/list"));
+}
+function toModelInfo(raw, modelId) {
+	if (!isRecord(raw)) throw new Error("Frigate+ model info: unexpected response shape");
+	const labelMap = {};
+	if (isRecord(raw.labelMap)) {
+		for (const [k, v] of Object.entries(raw.labelMap)) if (typeof v === "string") labelMap[k] = v;
+	}
+	return {
+		id: typeof raw.id === "string" ? raw.id : modelId,
+		type: typeof raw.type === "string" ? raw.type : "unknown",
+		width: typeof raw.width === "number" ? raw.width : 320,
+		height: typeof raw.height === "number" ? raw.height : 320,
+		labelMap
+	};
+}
+/** Resolve one model's metadata + presigned artifact URL. */
+async function requestPlusModelDownload(fetchFn, apiKey, plusModelId) {
+	const token = await fetchPlusAccessToken(fetchFn, apiKey);
+	const info = toModelInfo(await plusGet(fetchFn, token, `model/${plusModelId}`), plusModelId);
+	const signed = await plusGet(fetchFn, token, `model/${plusModelId}/signed_url`);
+	const url = isRecord(signed) && typeof signed.url === "string" ? signed.url : null;
+	if (url === null) throw new Error("Frigate+ signed_url response carried no url");
+	return {
+		info,
+		downloadUrl: url
+	};
+}
+/** Frigate+ model type → our format + decode. Mirrors the Frigate presets. */
+var PLUS_TYPE_MAP = {
+	mobiledet: {
+		format: "tflite",
+		postprocessor: "ssd",
+		extension: ".tflite"
+	},
+	yolonas: {
+		format: "onnx",
+		postprocessor: "yolonas",
+		extension: ".onnx"
+	},
+	yolov9: {
+		format: "onnx",
+		extension: ".onnx"
+	}
+};
+function plusTypeTraits(type) {
+	return PLUS_TYPE_MAP[type] ?? {
+		format: "onnx",
+		extension: ".onnx"
+	};
+}
+/** Ordered labels from the API's `index → label` map; holes keep alignment. */
+function orderedLabels(labelMap) {
+	const indices = Object.keys(labelMap).map((k) => Number.parseInt(k, 10)).filter((n) => Number.isInteger(n) && n >= 0);
+	if (indices.length === 0) return [];
+	const max = Math.max(...indices);
+	const out = [];
+	for (let i = 0; i <= max; i++) out.push(labelMap[String(i)] ?? `unknown-${i}`);
+	return out;
+}
+/**
+* Build the registrable descriptor for a downloaded Frigate+ model. The
+* artifact is hub-local (landed by the server-side download), so the URL uses
+* the `camstack-local://` convention (D208) — other nodes get it via
+* Distribute.
+*/
+function plusInfoToDescriptor(info, opts) {
+	const traits = plusTypeTraits(info.type);
+	const labels = orderedLabels(info.labelMap);
+	return {
+		stepId: "object-detection",
+		entry: {
+			id: opts.modelId,
+			name: opts.name,
+			description: `Frigate+ personal model (${info.type}) — imported via Model Studio`,
+			formats: { [traits.format]: {
+				url: `camstack-local://${opts.modelId}/${opts.filename}`,
+				sizeMB: opts.sizeMB,
+				runtimes: ["python"]
+			} },
+			inputSize: {
+				width: info.width,
+				height: info.height
+			},
+			labels: labels.map((name) => ({
+				id: name,
+				name
+			})),
+			preprocessMode: "letterbox",
+			...traits.postprocessor !== void 0 ? { postprocessor: traits.postprocessor } : {}
+		}
+	};
+}
 var MODEL_UPLOAD_ALLOWED_EXTENSIONS = [".onnx", ".tflite"];
 var FILENAME_RE = /^[a-zA-Z0-9._-]+$/;
 /**
@@ -34285,6 +34723,78 @@ var modelStudioActions = defineCustomActions({
 	}), { kind: "mutation" }),
 	abortModelUpload: customAction(object({ uploadId: string() }), object({ ok: literal(true) }), { kind: "mutation" }),
 	/**
+	* Curated PUBLIC Frigate model catalog (D214 addendum) — models Frigate
+	* uses/references that are downloadable without credentials, with verified
+	* metadata so the operator types nothing. Import downloads SERVER-SIDE into
+	* the hub's modelsDir and registers the descriptor with the public URL
+	* (other nodes download on demand — no Distribute needed).
+	*/
+	listFrigateCatalog: customAction(_void(), array(object({
+		id: string(),
+		label: string(),
+		format: _enum(MODEL_FORMATS),
+		sizeMB: number(),
+		inputSize: number(),
+		notes: string()
+	})).readonly()),
+	importFrigateCatalogModel: customAction(object({
+		catalogId: string(),
+		modelId: string().optional(),
+		name: string().optional()
+	}), object({
+		ok: literal(true),
+		modelId: string(),
+		bytes: number()
+	}), { kind: "mutation" }),
+	/**
+	* Frigate+ personal models. The API key lives in the addon's SETTINGS
+	* (password field) and never leaves the hub: list / test / import all run
+	* server-side against api.frigate.video. Status deliberately reveals only
+	* booleans — never the key.
+	*/
+	/**
+	* Nodes whose engine can actually LOAD a tflite artifact (the pool's only
+	* tflite runtime binds the Coral EdgeTPU delegate — no Coral, no tflite).
+	* The UI gates tflite imports on this instead of letting them fail at load.
+	*/
+	tfliteSupport: customAction(_void(), object({ nodes: array(string()).readonly() })),
+	frigatePlusStatus: customAction(_void(), object({
+		configured: boolean(),
+		keyFormatValid: boolean()
+	})),
+	frigatePlusTest: customAction(_void(), object({
+		ok: boolean(),
+		error: string().optional()
+	}), { kind: "mutation" }),
+	frigatePlusListModels: customAction(_void(), array(object({
+		id: string(),
+		name: string(),
+		type: string(),
+		isBaseModel: boolean(),
+		baseModel: string(),
+		supportedDetectors: array(string()).readonly(),
+		trainDate: string(),
+		hailoDevice: string().optional(),
+		verifiedImages: number(),
+		width: number().optional(),
+		height: number().optional()
+	})).readonly()),
+	importFrigatePlusModel: customAction(object({
+		plusModelId: string(),
+		modelId: string(),
+		name: string().optional()
+	}), object({
+		ok: literal(true),
+		modelId: string(),
+		bytes: number(),
+		conversions: array(object({
+			format: _enum(["openvino", "coreml"]),
+			ok: boolean(),
+			nodeId: string().optional(),
+			error: string().optional()
+		})).readonly()
+	}), { kind: "mutation" }),
+	/**
 	* Rank nodes for model conversion based on hardware capabilities.
 	* CoreML targets require darwin; OpenVINO targets require an OpenVINO-capable node.
 	*/
@@ -34367,18 +34877,9 @@ function spawnRunConvert(jobPath, pythonPath, onProgress, _sessionId) {
 		});
 	});
 }
-/**
-* Model Studio — provides the `custom-model-registry` collection cap (hub only)
-* and the `model-convert` singleton cap (any node).
-*
-* P1 maintained the durable list of custom detection models and exposed them
-* so the detection pipeline can offer them in its model picker.
-*
-* P3 adds the `model-convert` provider on EVERY node so agents can run
-* local Python conversion without routing through the hub.
-* The `custom-model-registry` cap and all customActions are hub-only.
-*/
-var ModelStudioAddon = class extends BaseAddon {
+/** Global-fetch adapter for the injected Frigate+ client seam. */
+var plusFetch = async (url, init) => fetch(url, init);
+var ModelStudioAddon = class ModelStudioAddon extends BaseAddon {
 	id = "model-studio";
 	modelsState = null;
 	availabilityState = null;
@@ -34400,7 +34901,21 @@ var ModelStudioAddon = class extends BaseAddon {
 		section: "detection"
 	}];
 	constructor() {
-		super({});
+		super({ frigatePlusApiKey: "" });
+	}
+	globalSettingsSchema() {
+		return this.schema({ sections: [{
+			id: "frigate-plus",
+			title: "Frigate+",
+			description: "Credentials for importing your personal Frigate+ models. Create an API key in your Frigate+ account (https://plus.frigate.video → Settings → API keys; see docs.frigate.video/integrations/plus). The key is used only server-side against api.frigate.video and is never sent to the browser.",
+			fields: [{
+				type: "password",
+				key: "frigatePlusApiKey",
+				label: "Frigate+ API key",
+				description: "Shape: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx:40-hex-chars",
+				showToggle: true
+			}]
+		}] });
 	}
 	makeConvertDeps() {
 		return {
@@ -34487,6 +35002,45 @@ var ModelStudioAddon = class extends BaseAddon {
 				listCustomModels: async () => this.listCustomModels(),
 				distributeModel: async (input) => this.distributeModel(input),
 				listAvailability: async () => this.availability_.get(),
+				listFrigateCatalog: async () => FRIGATE_PUBLIC_CATALOG.map((c) => ({
+					id: c.id,
+					label: c.label,
+					format: c.format,
+					sizeMB: c.sizeMB,
+					inputSize: c.inputSize,
+					notes: c.notes
+				})),
+				importFrigateCatalogModel: async (input) => this.importFrigateCatalogModel(input),
+				tfliteSupport: async () => {
+					const api = this.ctx.api;
+					if (!api) return { nodes: [] };
+					const nodes = await this.recommendDeps().listNodes();
+					const supported = [];
+					for (const nId of nodes) try {
+						if ((await api.platformProbe.getCapabilities.query({ nodeId: nId })).scores.some((sc) => sc.format === "tflite" && sc.available)) supported.push(nId);
+					} catch {}
+					return { nodes: supported };
+				},
+				frigatePlusStatus: async () => {
+					const key = this.config.frigatePlusApiKey ?? "";
+					return {
+						configured: key.length > 0,
+						keyFormatValid: isValidPlusApiKey(key)
+					};
+				},
+				frigatePlusTest: async () => {
+					try {
+						await fetchPlusAccessToken(plusFetch, this.config.frigatePlusApiKey ?? "");
+						return { ok: true };
+					} catch (err) {
+						return {
+							ok: false,
+							error: err instanceof Error ? err.message : "auth failed"
+						};
+					}
+				},
+				frigatePlusListModels: async () => listPlusModels(plusFetch, this.config.frigatePlusApiKey ?? ""),
+				importFrigatePlusModel: async (input) => this.importFrigatePlusModel(input),
 				recommendConvertNode: async (input) => {
 					const api = this.ctx.api;
 					if (!api) throw new Error("recommendConvertNode: ctx.api unavailable");
@@ -34616,6 +35170,170 @@ var ModelStudioAddon = class extends BaseAddon {
 			bytes: res.bytes
 		};
 	}
+	/** listNodes/hardwareOf deps for `recommendConvertNode` — shared by the
+	*  convert actions and the Frigate+ auto-conversion. */
+	recommendDeps() {
+		const api = this.ctx.api;
+		if (!api) throw new Error("model-studio: ctx.api unavailable");
+		return {
+			listNodes: async () => {
+				return (await api.addons.listCapabilityProviders.query({ capName: "model-convert" })).map((p) => {
+					const atIdx = p.addonId.indexOf("@");
+					return atIdx !== -1 ? p.addonId.slice(atIdx + 1) : "hub";
+				});
+			},
+			hardwareOf: async (nId) => {
+				const hw = await api.platformProbe.getHardware.query({ nodeId: nId });
+				const caps = await api.platformProbe.getCapabilities.query({ nodeId: nId });
+				return {
+					platform: hw.platform,
+					gpu: hw.gpu ?? void 0,
+					npu: hw.npu ?? void 0,
+					openvino: caps.scores.some((s) => s.format === "openvino" && s.available)
+				};
+			}
+		};
+	}
+	/** sha256 of a file on disk (streamed). */
+	static async fileSha256(filePath) {
+		const hash = crypto$1.createHash("sha256");
+		await new Promise((resolve, reject) => {
+			fs.createReadStream(filePath).on("data", (chunk) => hash.update(chunk)).on("end", () => resolve()).on("error", reject);
+		});
+		return hash.digest("hex");
+	}
+	/**
+	* Import a curated PUBLIC Frigate catalog model: download SERVER-SIDE into
+	* the hub's modelsDir (size-verified against the curated declaration),
+	* register the descriptor with the PUBLIC url (nodes download on demand),
+	* and record hub availability.
+	*/
+	async importFrigateCatalogModel(input) {
+		const cat = FRIGATE_PUBLIC_CATALOG.find((c) => c.id === input.catalogId);
+		if (!cat) throw new Error(`importFrigateCatalogModel: unknown catalog id "${input.catalogId}"`);
+		const descriptor = buildFrigateCatalogDescriptor(input.catalogId, {
+			...input.modelId !== void 0 ? { modelId: input.modelId } : {},
+			...input.name !== void 0 ? { name: input.name } : {}
+		});
+		const modelsDir = await this.resolveModelsDir();
+		const filename = cat.url.split("/").at(-1) ?? `${descriptor.entry.id}.${cat.format}`;
+		const destPath = path.join(modelsDir, filename);
+		await downloadFile(cat.url, destPath);
+		const bytes = (await fs.promises.stat(destPath)).size;
+		const declaredBytes = cat.sizeMB * 1e6;
+		if (bytes < declaredBytes * .5 || bytes > declaredBytes * 2) {
+			await fs.promises.rm(destPath, { force: true });
+			throw new Error(`importFrigateCatalogModel: downloaded ${bytes} bytes but the catalog declares ~${Math.round(declaredBytes)} — refusing to register a suspicious artifact`);
+		}
+		const sha256 = await ModelStudioAddon.fileSha256(destPath);
+		await this.registerCustomModel(descriptor);
+		await this.availability_.update((prev) => upsertAvailability(prev, descriptor.entry.id, "hub", {
+			format: cat.format,
+			sha256,
+			bytes,
+			at: Date.now()
+		}));
+		this.ctx.logger.info("Imported Frigate catalog model", { meta: {
+			catalogId: input.catalogId,
+			modelId: descriptor.entry.id,
+			bytes,
+			sha256
+		} });
+		return {
+			ok: true,
+			modelId: descriptor.entry.id,
+			bytes
+		};
+	}
+	/**
+	* Import one of the operator's personal Frigate+ models: resolve metadata +
+	* presigned URL with the SECRET key (server-side only), download into the
+	* hub's modelsDir, and register with the model-type-derived characteristics
+	* (format, decode, input size, labelmap — nothing hand-typed). The artifact
+	* is hub-local: other nodes get it via Models → Distribute.
+	*/
+	async importFrigatePlusModel(input) {
+		if (!/^[a-zA-Z0-9._-]+$/.test(input.modelId)) throw new Error(`importFrigatePlusModel: model id "${input.modelId}" is invalid`);
+		const key = this.config.frigatePlusApiKey ?? "";
+		const { info, downloadUrl } = await requestPlusModelDownload(plusFetch, key, input.plusModelId);
+		const traits = plusTypeTraits(info.type);
+		const filename = `${input.modelId}${traits.extension}`;
+		const modelsDir = await this.resolveModelsDir();
+		const destPath = path.join(modelsDir, filename);
+		await downloadFile(downloadUrl, destPath);
+		const bytes = (await fs.promises.stat(destPath)).size;
+		if (bytes < 1e4) {
+			await fs.promises.rm(destPath, { force: true });
+			throw new Error(`importFrigatePlusModel: downloaded only ${bytes} bytes — the signed URL likely expired or the response was an error page`);
+		}
+		const sha256 = await ModelStudioAddon.fileSha256(destPath);
+		const descriptor = plusInfoToDescriptor(info, {
+			modelId: input.modelId,
+			name: input.name?.trim() || `Frigate+ ${info.type} (${input.plusModelId.slice(0, 8)})`,
+			filename,
+			sizeMB: Number((bytes / 1e6).toFixed(1))
+		});
+		await this.registerCustomModel(descriptor);
+		await this.availability_.update((prev) => upsertAvailability(prev, input.modelId, "hub", {
+			format: traits.format,
+			sha256,
+			bytes,
+			at: Date.now()
+		}));
+		this.ctx.logger.info("Imported Frigate+ model", { meta: {
+			plusModelId: input.plusModelId,
+			modelId: input.modelId,
+			type: info.type,
+			bytes
+		} });
+		let conversions = [];
+		if (traits.format === "onnx") {
+			const api = this.ctx.api;
+			if (api) {
+				conversions = await runPlusConversions({
+					recommend: (i) => recommendConvertNode(i, this.recommendDeps()),
+					convert: (convertInput, nId) => api.modelConvert.convert.mutate(convertInput, nodePin(nId)),
+					freshSourceUrl: async () => (await requestPlusModelDownload(plusFetch, key, input.plusModelId)).downloadUrl,
+					upsertEntry: async (entry) => {
+						await this.state_.update((prev) => upsertCustomModel(prev, {
+							stepId: descriptor.stepId,
+							entry
+						}));
+					},
+					markAvailable: async (nId, mId, artifacts) => {
+						await this.availability_.update((prev) => {
+							const seen = /* @__PURE__ */ new Set();
+							let next = prev;
+							for (const artifact of artifacts) {
+								if (seen.has(artifact.format)) continue;
+								seen.add(artifact.format);
+								next = upsertAvailability(next, mId, nId, {
+									format: artifact.format,
+									sha256: "",
+									bytes: Math.round(artifact.sizeMB * 1e6),
+									at: Date.now()
+								});
+							}
+							return next;
+						});
+					}
+				}, {
+					entry: descriptor.entry,
+					targetFormats: ["openvino", "coreml"]
+				});
+				this.ctx.logger.info("Frigate+ import — engine conversions", { meta: {
+					modelId: input.modelId,
+					outcomes: conversions.map((o) => ({ ...o }))
+				} });
+			}
+		}
+		return {
+			ok: true,
+			modelId: input.modelId,
+			bytes,
+			conversions
+		};
+	}
 	async registerCustomModel(input) {
 		if (!input.stepId.trim()) throw new Error("registerCustomModel: stepId is required");
 		if (!input.entry.id.trim()) throw new Error("registerCustomModel: entry.id is required");