@camstack/addon-model-studio 1.1.31 → 1.1.33

package/dist/model-studio.addon.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
-import crypto$1 from "node:crypto";
+import crypto$1, { createHash, randomUUID } from "node:crypto";
 import * as fs$1 from "node:fs";
 import fs from "node:fs";
 import os from "node:os";
@@ -7677,7 +7677,7 @@ var RecordingBandSchema = object({
 	postBufferSec: number().min(0).optional()
 });
 ({
-	preBufferSec: 10,
+	preBufferSec: 15,
 	postBufferSec: 30
 }).postBufferSec * 1e3;
 /**
@@ -13657,128 +13657,103 @@ var COCO_TO_MACRO = {
 var AUDIO_MACRO_LABELS = [
 	{
 		id: "speech",
-		name: "Speech",
-		icon: "🗣️"
+		name: "Speech"
 	},
 	{
 		id: "scream",
-		name: "Scream / Shout",
-		icon: "😱"
+		name: "Scream / Shout"
 	},
 	{
 		id: "crying",
-		name: "Crying / Baby",
-		icon: "😢"
+		name: "Crying / Baby"
 	},
 	{
 		id: "laughter",
-		name: "Laughter",
-		icon: "😂"
+		name: "Laughter"
 	},
 	{
 		id: "music",
-		name: "Music",
-		icon: "🎵"
+		name: "Music"
 	},
 	{
 		id: "dog",
-		name: "Dog",
-		icon: "🐕"
+		name: "Dog"
 	},
 	{
 		id: "cat",
-		name: "Cat",
-		icon: "🐈"
+		name: "Cat"
 	},
 	{
 		id: "bird",
-		name: "Bird",
-		icon: "🐦"
+		name: "Bird"
 	},
 	{
 		id: "animal",
-		name: "Animal (other)",
-		icon: "🐾"
+		name: "Animal (other)"
 	},
 	{
 		id: "alarm",
-		name: "Alarm / Siren",
-		icon: "🚨"
+		name: "Alarm / Siren"
 	},
 	{
 		id: "doorbell",
-		name: "Doorbell / Knock",
-		icon: "🔔"
+		name: "Doorbell / Knock"
 	},
 	{
 		id: "glass_breaking",
-		name: "Glass Breaking",
-		icon: "💥"
+		name: "Glass Breaking"
 	},
 	{
 		id: "gunshot",
-		name: "Gunshot / Explosion",
-		icon: "💣"
+		name: "Gunshot / Explosion"
 	},
 	{
 		id: "vehicle",
-		name: "Vehicle",
-		icon: "🚗"
+		name: "Vehicle"
 	},
 	{
 		id: "siren",
-		name: "Emergency Siren",
-		icon: "🚑"
+		name: "Emergency Siren"
 	},
 	{
 		id: "fire",
-		name: "Fire / Smoke",
-		icon: "🔥"
+		name: "Fire / Smoke"
 	},
 	{
 		id: "water",
-		name: "Water",
-		icon: "💧"
+		name: "Water"
 	},
 	{
 		id: "wind",
-		name: "Wind / Weather",
-		icon: "🌬️"
+		name: "Wind / Weather"
 	},
 	{
 		id: "door",
-		name: "Door",
-		icon: "🚪"
+		name: "Door"
 	},
 	{
 		id: "footsteps",
-		name: "Footsteps",
-		icon: "👣"
+		name: "Footsteps"
 	},
 	{
 		id: "crowd",
-		name: "Crowd / Chatter",
-		icon: "👥"
+		name: "Crowd / Chatter"
 	},
 	{
 		id: "telephone",
-		name: "Telephone",
-		icon: "📞"
+		name: "Telephone"
 	},
 	{
 		id: "engine",
-		name: "Engine / Motor",
-		icon: "⚙️"
+		name: "Engine / Motor"
 	},
 	{
 		id: "tools",
-		name: "Tools / Construction",
-		icon: "🔨"
+		name: "Tools / Construction"
 	},
 	{
 		id: "silence",
-		name: "Silence",
-		icon: "🤫"
+		name: "Silence"
 	}
 ];
 var YAMNET_TO_MACRO = {
@@ -16242,7 +16217,7 @@ var TrackEnvelopeSchema = object({
 * `snapshots[]` references — megabytes across a page of tracks. `slim`
 * keeps every scalar the list surfaces actually render (ids, class(es),
 * label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
-* zonesVisited, bestEventId, envelope, hasFace, hasRider) and returns `positions` /
+* zonesVisited, bestEventId, envelope, hasFace, hasEmbeddedFace, hasRider) and returns `positions` /
 * `snapshots` as EMPTY arrays — detail views re-fetch the full row via
 * `getTrack`. Mirrors the event-store `projection` convention
 * (`getObjectEvents` et al.).
@@ -16537,6 +16512,35 @@ var TrackSchema = object({
 	*/
 	hasFace: boolean().optional(),
 	/**
+	* This track has a face row IN THE GALLERY: a crop **and** an embedding — a
+	* face an operator could ASSIGN to an identity.
+	*
+	* The STRICT twin of {@link hasFace}, and the pair only earns its keep
+	* because the two disagree. `hasFace` is stamped at the TOP of the face
+	* branch, before every gate, and means no more than "a face detector produced
+	* a face detail". This one is stamped at the single moment the gallery row
+	* LANDS — after `FaceRecognizer.onTrackEnd` successfully persists it, i.e.
+	* past the embedding-magnitude verdict, the `minFacePx` detection gate, the
+	* candidate gate, the imageless-track drop (no crop was ever captured) and
+	* the crop-store drop. Everything between the detector and that insert can
+	* legitimately refuse the face, so a flag written any earlier promises the
+	* operator something to assign and delivers nothing.
+	*
+	* **Independent of recognition.** A face collected but never auto-matched is
+	* still assignable — it is in fact the face an operator most wants to reach —
+	* so this is NOT gated on `recognizedIdentityId`. Recognition lands in
+	* `subLabel`; this says only that the raw material exists.
+	*
+	* **Set once, never cleared.** A track that produced a gallery row produced
+	* one; deleting the row later is the gallery's business, not this flag's.
+	*
+	* **Absent ≠ false**, the same rule as {@link hasFace}: every row written
+	* before the column omits it, and so does every server that predates the
+	* field. A consumer must test `=== true` and render nothing otherwise —
+	* never infer "no assignable face".
+	*/
+	hasEmbeddedFace: boolean().optional(),
+	/**
 	* This subject CONTAINS a folded rider — a person the rider-pairing step
 	* ([D34](../decisions/adr-0034.md)) removed from the frame BEFORE the tracker,
 	* so the passage is tracked once and as a VEHICLE.
@@ -17886,6 +17890,32 @@ var DetailResultSchema = object({
 	/** FRAME-space bbox (already mapped back from crop space). */
 	bbox: NativeCropBboxSchema.optional(),
 	embedding: string().optional(),
+	/**
+	* L2 magnitude of the RAW pre-normalization embedding. Additive and optional
+	* so an older runner that does not send it degrades to "unmeasurable", which
+	* the consuming gate treats as accept — never as reject.
+	*/
+	embeddingMagnitude: number().optional(),
+	/**
+	* Model that produced `embedding` — the SAME contract `labelModelId` has for
+	* `label`, and for the same reason: the producing node is the only side that
+	* knows which model actually ran, and re-deriving it downstream is exactly
+	* the inference this model exists to forbid.
+	*
+	* Additive and optional, so a runner that predates it degrades to
+	* "unmeasurable" rather than to a wrong answer — the consumer falls back to
+	* its previous assumption instead of refusing.
+	*
+	* Its absence was not cosmetic. `FaceRecognizer` needs the probe's model id
+	* to use `face-matcher`'s same-model gate (`sample.modelId !== probe.modelId`);
+	* with nothing on the wire it took the id from the GALLERY, so the gate
+	* compared the gallery against itself and could never fire. That turned the
+	* one guard protecting the face feature space into a tautology, and it is
+	* why swapping `face-embedding`'s model would NOT have stranded the enrolled
+	* gallery as the catalog comment predicts — it would have scored the new
+	* model's vectors against the old model's samples in one cosine space.
+	*/
+	embeddingModelId: string().optional(),
 	label: string().optional(),
 	/**
 	* The tier `label` occupies, copied VERBATIM from the producing step's
@@ -18761,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(),
@@ -18791,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(),
@@ -19296,6 +19342,7 @@ DeviceType.Camera, method(object({
 		isBattery: boolean(),
 		reason: _enum([
 			"disabled",
+			"offline",
 			"sleeping",
 			"unreachable",
 			"waking"
@@ -19341,9 +19388,17 @@ targets: array(object({
 	sleeping: boolean(),
 	/** Current device state rendered over the cached frame. State images
 	*  remain authoritative even when their photographic background is
-	*  old; null means the link must carry a current camera frame. */
+	*  old; null means the link must carry a current camera frame.
+	*
+	*  **This is the ONLY source a surface may derive an inactive tile
+	*  from.** A client that reads a device's `online`/`disabled` flags and
+	*  draws its own verdict will disagree with the pixels it is painting
+	*  — the frame comes from here, and so must the sentence over it
+	*  (D190). Pair with `ageMs` for the age of the photograph behind the
+	*  state. */
 	stateReason: _enum([
 		"disabled",
+		"offline",
 		"sleeping",
 		"unreachable",
 		"waking"
@@ -22540,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. */
@@ -22583,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
@@ -22604,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(),
@@ -33529,7 +33629,6 @@ var NC_AUDIO_DEFAULTS = {
 	hitPercent: 60,
 	samplingSeconds: 10
 };
-new Map(AUDIO_MACRO_LABELS.flatMap((macro) => macro.icon === void 0 ? [] : [[macro.id, macro.icon]]));
 new Set(["devices", "classes"]);
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
 /**
@@ -33763,6 +33862,39 @@ TimelapseRuleInputSchema.extend({
 	createdAt: number(),
 	updatedAt: number()
 });
+Object.freeze(Object.fromEntries([{
+	stepId: "face-embedding",
+	label: "Face recognition model",
+	defaultModelId: "arcface-r100",
+	indexName: "the enrolled face gallery",
+	options: [
+		{
+			id: "arcface-r100",
+			label: "ArcFace (ResNet34)"
+		},
+		{
+			id: "auraface-r100",
+			label: "AuraFace R100"
+		},
+		{
+			id: "inception-resnet-v1",
+			label: "Inception ResNet V1"
+		}
+	]
+}, {
+	stepId: "clip-embedding",
+	label: "Semantic search model",
+	defaultModelId: "mobileclip-s1",
+	indexName: "the object semantic-search index",
+	options: [{
+		id: "mobileclip-s1",
+		label: "MobileCLIP S1"
+	}, {
+		id: "mobileclip-s2",
+		label: "MobileCLIP S2"
+	}]
+}].map((s) => [s.stepId, s.defaultModelId])));
+string().min(1);
 object({
 	/**
 	* Fraction of the box's own size added on EACH side before cutting.
@@ -33783,10 +33915,21 @@ object({
 	*/
 	square: boolean()
 });
-({
+/**
+* The convention in force when nobody has configured one — byte-for-byte the
+* behaviour of the pre-unification LIVE path (`DETAIL_CROP_PADDING_RATIO`).
+*/
+var DEFAULT_DETAIL_CROP_CONVENTION = {
 	paddingRatio: .15,
 	square: false
-}).paddingRatio;
+};
+Object.freeze({
+	x: 0,
+	y: 0,
+	w: 1,
+	h: 1
+});
+DEFAULT_DETAIL_CROP_CONVENTION.paddingRatio;
 /**
 * WHICH delivered frames the decode worker retains a native copy of.
 *
@@ -34062,6 +34205,462 @@ 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._-]+$/;
+/**
+* Validate an upload filename: plain basename (no separators, no traversal),
+* conservative charset, allowlisted model extension. Returns it unchanged so
+* call sites read as an assertion. Throws with an actionable message.
+*/
+function sanitizeModelFilename(filename) {
+	if (filename.includes("/") || filename.includes("\\") || filename.includes("..") || !FILENAME_RE.test(filename)) throw new Error(`Invalid model filename "${filename}" — plain basename with letters, digits, dot, underscore, hyphen only`);
+	if (!MODEL_UPLOAD_ALLOWED_EXTENSIONS.some((ext) => filename.endsWith(ext))) throw new Error(`Unsupported model file extension on "${filename}" — expected one of ${MODEL_UPLOAD_ALLOWED_EXTENSIONS.join(", ")}`);
+	return filename;
+}
+var ModelUploadStore = class {
+	uploads = /* @__PURE__ */ new Map();
+	opts;
+	maxBytes;
+	constructor(opts) {
+		this.opts = opts;
+		this.maxBytes = opts.maxBytes ?? 536870912;
+	}
+	begin(input) {
+		const filename = sanitizeModelFilename(input.filename);
+		if (!Number.isFinite(input.totalBytes) || input.totalBytes <= 0) throw new Error("totalBytes must be a positive number");
+		if (input.totalBytes > this.maxBytes) throw new Error(`Upload too large: ${input.totalBytes} bytes exceeds the ${this.maxBytes}-byte cap`);
+		fs$1.mkdirSync(this.opts.stagingDir, { recursive: true });
+		const uploadId = randomUUID();
+		const stagingPath = path$1.join(this.opts.stagingDir, `${uploadId}-${filename}`);
+		fs$1.writeFileSync(stagingPath, Buffer.alloc(0));
+		this.uploads.set(uploadId, {
+			filename,
+			totalBytes: input.totalBytes,
+			stagingPath,
+			hash: createHash("sha256"),
+			received: 0
+		});
+		return { uploadId };
+	}
+	append(input) {
+		const upload = this.mustGet(input.uploadId);
+		const chunk = Buffer.from(input.chunkBase64, "base64");
+		if (chunk.length === 0) throw new Error("Empty chunk");
+		if (upload.received + chunk.length > upload.totalBytes) {
+			this.abort({ uploadId: input.uploadId });
+			throw new Error(`Chunk exceeds the declared totalBytes (${upload.totalBytes}) — upload aborted`);
+		}
+		fs$1.appendFileSync(upload.stagingPath, chunk);
+		upload.hash.update(chunk);
+		upload.received += chunk.length;
+		return { received: upload.received };
+	}
+	commit(input) {
+		const upload = this.mustGet(input.uploadId);
+		if (upload.received !== upload.totalBytes) throw new Error(`Upload incomplete: received ${upload.received} of ${upload.totalBytes} bytes`);
+		fs$1.mkdirSync(this.opts.modelsDir, { recursive: true });
+		const destPath = path$1.join(this.opts.modelsDir, upload.filename);
+		fs$1.renameSync(upload.stagingPath, destPath);
+		this.uploads.delete(input.uploadId);
+		return {
+			filename: upload.filename,
+			bytes: upload.received,
+			sha256: upload.hash.digest("hex")
+		};
+	}
+	abort(input) {
+		const upload = this.uploads.get(input.uploadId);
+		if (upload) {
+			try {
+				fs$1.rmSync(upload.stagingPath, { force: true });
+			} catch {}
+			this.uploads.delete(input.uploadId);
+		}
+		return { ok: true };
+	}
+	mustGet(uploadId) {
+		const upload = this.uploads.get(uploadId);
+		if (!upload) throw new Error(`Unknown uploadId "${uploadId}" — begin a new upload`);
+		return upload;
+	}
+};
 //#endregion
 //#region src/model-studio-actions.ts
 /**
@@ -34102,6 +34701,100 @@ var modelStudioActions = defineCustomActions({
 	}), { kind: "mutation" }),
 	listAvailability: customAction(_void(), ModelAvailabilityMapSchema),
 	/**
+	* Chunked model-file upload (Frigate import). One tRPC mutation cannot
+	* carry a model file (hub HTTP body limit ~1 MB), so the page streams
+	* base64 chunks: begin → append× → commit. Commit lands the artifact in the
+	* hub's shared modelsDir, where the `camstack-local://` catalog-URL
+	* convention resolves it by basename and `model-distributor` can ship it to
+	* agents. Abort (or an oversize chunk) discards the staging file.
+	*/
+	beginModelUpload: customAction(object({
+		filename: string(),
+		totalBytes: number().int().positive()
+	}), object({ uploadId: string() }), { kind: "mutation" }),
+	appendModelUpload: customAction(object({
+		uploadId: string(),
+		chunkBase64: string()
+	}), object({ received: number() }), { kind: "mutation" }),
+	commitModelUpload: customAction(object({ uploadId: string() }), object({
+		filename: string(),
+		bytes: number(),
+		sha256: string()
+	}), { 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.
 	*/
@@ -34184,21 +34877,14 @@ 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;
+	/** Lazily-built chunked-upload store (hub only) — see `upload/model-upload-store.ts`. */
+	uploadStore = null;
 	/**
 	* Module-Federation page declaration surfaced via the `addon-pages-source`
 	* collection cap. Mirrors the manifest `pages[]` entry — admin-ui's
@@ -34215,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 {
@@ -34285,11 +34985,62 @@ var ModelStudioAddon = class extends BaseAddon {
 			providers,
 			customActions: isHub ? modelStudioActions : void 0,
 			actionHandlers: isHub ? {
+				beginModelUpload: async (input) => (await this.getUploadStore()).begin(input),
+				appendModelUpload: async (input) => (await this.getUploadStore()).append(input),
+				commitModelUpload: async (input) => {
+					const result = (await this.getUploadStore()).commit(input);
+					this.ctx.logger.info("Model upload landed in modelsDir", { meta: {
+						filename: result.filename,
+						bytes: result.bytes,
+						sha256: result.sha256
+					} });
+					return result;
+				},
+				abortModelUpload: async (input) => (await this.getUploadStore()).abort(input),
 				registerCustomModel: async (input) => this.registerCustomModel(input),
 				removeCustomModel: async (input) => this.removeCustomModel(input),
 				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");
@@ -34366,6 +35117,22 @@ var ModelStudioAddon = class extends BaseAddon {
 			} : void 0
 		};
 	}
+	/**
+	* Build (once) the upload store, anchored at this node's writable data root:
+	* staging under `<dataDir>/model-uploads`, commits into the SHARED
+	* `<nodeDataDir>/models` — the same directory every inference addon loads
+	* from, which is what makes the `camstack-local://` URL convention resolve.
+	*/
+	async getUploadStore() {
+		if (this.uploadStore) return this.uploadStore;
+		const modelsDir = await this.resolveModelsDir();
+		const stagingDir = path.join(this.ctx.dataDir ?? os.tmpdir(), "model-uploads");
+		this.uploadStore = new ModelUploadStore({
+			stagingDir,
+			modelsDir
+		});
+		return this.uploadStore;
+	}
 	get state_() {
 		if (!this.modelsState) throw new Error("ModelStudioAddon: durable state not initialized");
 		return this.modelsState;
@@ -34403,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");