@camstack/addon-pipeline 1.2.103 → 1.2.105

package/dist/{dist-C11WuNUP.js → dist-DVMPCqaj.js}

@@ -8568,12 +8568,25 @@ var RecordingBandSchema = object({
 * segment is ever finalized and the camera records nothing anyway. At the 10 s
 * default segment length, 30 s leaves room for two full segments. `preBufferSec`
 * is retroactive only — it costs nothing at record time, it merely keeps
-* already-written segments — so it is set to one segment length.
+* already-written segments.
 *
-* An EXPLICIT `0` is left alone: that is an operator statement, not an omission.
+* ## Why `preBufferSec` is 15 and not one segment length
+*
+* It has to cover the broker's RECORDING pre-roll, which is media handed to the
+* writer from BEFORE the trigger (D192/D193). If this bound were narrower, the
+* keep gate would delete the very seconds the ring just supplied — two
+* authorities disagreeing about the same footage, which is the failure D191 was
+* written against. It is therefore set to `RECORDING_PRE_ROLL_MAX_MS` (15 s),
+* the widest window the broker can be configured to serve, so an operator
+* raising the cluster pre-roll can never walk past the gate silently. The
+* addon-side guard is
+* `packages/addon-pipeline/src/recorder/addon/__tests__/band-decision.spec.ts`.
+*
+* An EXPLICIT `0` is left alone: that is an operator statement, not an omission,
+* and it is excluded from that invariant by name.
 */
 var DEFAULT_EVENTS_BAND_BUFFER_SEC = {
-	preBufferSec: 10,
+	preBufferSec: 15,
 	postBufferSec: 30
 };
 DEFAULT_EVENTS_BAND_BUFFER_SEC.postBufferSec * 1e3;
@@ -17906,7 +17919,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.).
@@ -18201,6 +18214,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.
@@ -19708,6 +19750,26 @@ var DetailResultSchema = object({
 	* 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
@@ -20725,6 +20787,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(),
@@ -20755,7 +20823,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(),
@@ -21260,6 +21338,7 @@ DeviceType.Camera, method(object({
 		isBattery: boolean(),
 		reason: _enum([
 			"disabled",
+			"offline",
 			"sleeping",
 			"unreachable",
 			"waking"
@@ -21305,9 +21384,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"
@@ -24666,7 +24753,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. */
@@ -24709,7 +24801,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
@@ -24730,8 +24857,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(),
@@ -36110,6 +36242,153 @@ TimelapseRuleInputSchema.extend({
 	createdAt: number(),
 	updatedAt: number()
 });
+/**
+* A model choice has a SCOPE, and a scope change has a workflow.
+*
+* ## The two scopes
+*
+* Almost every pipeline step's model is a **node** question: which build runs
+* fastest on THIS accelerator. Two nodes may legitimately answer differently —
+* a Coral runs the tflite SSD, a Mac runs the coreml YOLO — because the answers
+* are compared against nothing. They produce boxes, and a box is a box.
+*
+* Two steps are not like that. `face-embedding` and `clip-embedding` produce
+* **vectors that land in ONE shared index** (`identity_samples`,
+* `vec_object_clip`) and are ranked against each other by cosine similarity.
+* Cosine similarity between two encoders is not a weak signal, it is a
+* meaningless number — and nothing inside a vector can tell you it happened.
+* So for those two steps the model is a **cluster** question with exactly one
+* answer, stored in exactly one row.
+*
+* That is the same argument [D52](../../../../docs/decisions/adr-0052.md) makes
+* for the crop convention (`detail-crop.ts`), one level up: the crop decides
+* WHAT pixels the encoder sees, this decides WHICH encoder sees them. Both are
+* cluster-wide for the same reason and neither may become per-node.
+*
+* ## Why the registry lives here and not in the step catalog
+*
+* The scope itself is declared on the step, in
+* `detection-pipeline/registry/step-definitions.ts` (`StepDefinition.modelScope`)
+* — that is where a new step declares what kind of choice its model is. But the
+* catalog lives inside `addon-pipeline`, and three packages that must NOT
+* import an addon need to know the set: the orchestrator (which renders and
+* stores the row), post-analysis (which pins the row for a re-embed pass) and
+* admin-ui (which mirrors it). So the set is mirrored here, and
+* `scripts/check-cluster-model-scope.ts` fails the build when the two disagree.
+* A hand-copied key that stops matching is exactly how a setting silently stops
+* arriving while both sides still look correct.
+*
+* ## The defaults ARE today's behaviour
+*
+* {@link DEFAULT_CLUSTER_STEP_MODELS} reproduces the catalog `defaultModelId`
+* of both steps. Declaring the scope therefore changes nothing on the day it
+* ships: the cluster row starts out saying what every node was already doing.
+* Changing it is legitimate — that is what the knob is for — but it invalidates
+* the stored vectors of that surface, and must be followed by a re-embed pass
+* (`face-reembed-pass.ts`, `embedding-rebuild.ts`).
+*/
+/**
+* The cluster-scoped steps. Mirrored from the catalog's `modelScope: 'cluster'`
+* declarations and guarded by `scripts/check-cluster-model-scope.ts`.
+*/
+var CLUSTER_MODEL_SCOPED_STEPS = [{
+	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"
+	}]
+}];
+/**
+* The settings key holding one step's cluster model choice.
+*
+* Step-qualified so the keys stay unique across the addon's whole schema, which
+* is what lets {@link pickClusterStepModels} walk every section instead of
+* trusting the section id.
+*/
+function clusterModelSettingKey(stepId) {
+	return `clusterModel:${stepId}`;
+}
+/** The cluster row when nobody has configured one — today's catalog defaults. */
+var DEFAULT_CLUSTER_STEP_MODELS = Object.freeze(Object.fromEntries(CLUSTER_MODEL_SCOPED_STEPS.map((s) => [s.stepId, s.defaultModelId])));
+/** A stored choice is a non-empty model id, or it is not a choice. */
+var ChosenModelIdSchema = string().min(1);
+/**
+* Narrow a FLAT settings record to the cluster row.
+*
+* Per-FIELD fallback, deliberately (same rule as `readDetailCropConvention`): a
+* junk face model must not also discard a valid clip model. An absent, empty or
+* non-string value resolves to the step's catalog default — the historical
+* behaviour — never to a blank id, because a blank id downstream becomes
+* "substitute the format default", which is precisely the substitution this
+* scope exists to forbid.
+*/
+function readClusterStepModels(config) {
+	const out = {};
+	for (const step of CLUSTER_MODEL_SCOPED_STEPS) {
+		const parsed = ChosenModelIdSchema.safeParse(config[clusterModelSettingKey(step.stepId)]);
+		out[step.stepId] = parsed.success ? parsed.data : step.defaultModelId;
+	}
+	return out;
+}
+function isHydratedField$2(entry) {
+	return typeof entry === "object" && entry !== null && "key" in entry;
+}
+/**
+* Extract the cluster row from an `addon-settings.getGlobalSettings` payload.
+*
+* Walks EVERY section rather than looking inside {@link CLUSTER_MODEL_SECTION_ID}
+* alone: the keys are unique across the addon's schema, and a section rename
+* must not silently revert the whole cluster to the defaults. A `null` payload
+* (addon mid-boot) is the defaults.
+*/
+function pickClusterStepModels(view) {
+	if (view === null) return DEFAULT_CLUSTER_STEP_MODELS;
+	const flat = {};
+	const wanted = new Set(CLUSTER_MODEL_SCOPED_STEPS.map((s) => clusterModelSettingKey(s.stepId)));
+	for (const section of view.sections) for (const entry of section.fields) {
+		if (!isHydratedField$2(entry) || typeof entry.key !== "string") continue;
+		if (wanted.has(entry.key)) flat[entry.key] = entry.value;
+	}
+	return readClusterStepModels(flat);
+}
+/**
+* The cluster model for `stepId`, or `null` when the step is node-scoped.
+*
+* `null` is the signal to LEAVE THE CALLER'S RESOLUTION ALONE — it is not "no
+* model". Returning a default here for a node-scoped step would quietly
+* override every per-(node,device) selection in the fleet.
+*/
+function resolveClusterStepModelId(stepId, models) {
+	const step = CLUSTER_MODEL_SCOPED_STEPS.find((s) => s.stepId === stepId);
+	if (step === void 0) return null;
+	const chosen = models[stepId];
+	return chosen !== void 0 && chosen !== "" ? chosen : step.defaultModelId;
+}
 var DETAIL_CROP_PADDING_KEY = "detailCropPaddingRatio";
 var DETAIL_CROP_SQUARE_KEY = "detailCropSquare";
 /**
@@ -36181,6 +36460,12 @@ function pickDetailCropConvention(view) {
 	}
 	return readDetailCropConvention(flat);
 }
+Object.freeze({
+	x: 0,
+	y: 0,
+	w: 1,
+	h: 1
+});
 DEFAULT_DETAIL_CROP_CONVENTION.paddingRatio;
 /**
 * Derive the crop rectangle for one parent detection.
@@ -37223,6 +37508,12 @@ Object.defineProperty(exports, "DEFAULT_AUDIO_ANALYZER_CONFIG", {
 		return DEFAULT_AUDIO_ANALYZER_CONFIG;
 	}
 });
+Object.defineProperty(exports, "DEFAULT_CLUSTER_STEP_MODELS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_CLUSTER_STEP_MODELS;
+	}
+});
 Object.defineProperty(exports, "DEFAULT_DETAIL_CROP_CONVENTION", {
 	enumerable: true,
 	get: function() {
@@ -37625,6 +37916,12 @@ Object.defineProperty(exports, "parseProfileBrokerId", {
 		return parseProfileBrokerId;
 	}
 });
+Object.defineProperty(exports, "pickClusterStepModels", {
+	enumerable: true,
+	get: function() {
+		return pickClusterStepModels;
+	}
+});
 Object.defineProperty(exports, "pickDetailCropConvention", {
 	enumerable: true,
 	get: function() {
@@ -37667,6 +37964,12 @@ Object.defineProperty(exports, "recordingExportCapability", {
 		return recordingExportCapability;
 	}
 });
+Object.defineProperty(exports, "resolveClusterStepModelId", {
+	enumerable: true,
+	get: function() {
+		return resolveClusterStepModelId;
+	}
+});
 Object.defineProperty(exports, "resolveEgressDecodeHwAccel", {
 	enumerable: true,
 	get: function() {

package/dist/{event-loop-stall-monitor-Cq_NeC4o.js → event-loop-stall-monitor-BazdZ0g0.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-C11WuNUP.js");
+const require_dist = require("./dist-DVMPCqaj.js");
 let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";
@@ -737,9 +737,39 @@ var PACKAGE_DETECTION_MODELS = [{
 	}
 }];
 var PLATE_OCR_MODELS = [{
+	id: "cct-s-v2-global",
+	name: "CCT-S v2 Global — License Plate",
+	description: "fast-plate-ocr CCT-S v2 — a dedicated license-plate reader (66 regions incl. Germany). 19/21 exact on the cam-617 ground-truth set vs 4/21 for the generic VGG text recognizer, with zero false reads on 18 junk ROIs",
+	inputSize: {
+		width: 128,
+		height: 64
+	},
+	inputLayout: "nhwc",
+	labels: [{
+		id: "text",
+		name: "Plate Text"
+	}],
+	preprocessMode: "resize",
+	postprocessor: "plate-slots",
+	license: "MIT",
+	formats: {
+		onnx: {
+			url: hf("plateRecognition/cct-s-v2-global/onnx/camstack-cct-s-v2-global.onnx"),
+			sizeMB: 5.3
+		},
+		coreml: {
+			url: hf("plateRecognition/cct-s-v2-global/coreml/camstack-cct-s-v2-global.mlpackage"),
+			sizeMB: 5.1,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("plateRecognition/cct-s-v2-global/openvino/camstack-cct-s-v2-global.xml"), 5)
+	}
+}, {
 	id: "vgg-english-g2",
 	name: "VGG English G2",
-	description: "EasyOCR VGG English G2 — text recognition for license plates and scene text",
+	description: "EasyOCR VGG English G2 — generic English text recognition. Superseded as the plate-OCR default by cct-s-v2-global (4/21 vs 19/21 exact on the cam-617 set); kept selectable for non-plate scene text and for any node pinned to it",
 	inputSize: {
 		width: 384,
 		height: 64
@@ -1107,95 +1137,55 @@ var INSTANCE_SEGMENTATION_MODELS = [
 		}
 	}
 ];
-var CLIP_EMBEDDING_MODELS = [
-	{
-		id: "mobileclip-s0",
-		name: "MobileCLIP S0",
-		description: "MobileCLIP S0 — Apple ultra-fast CLIP vision encoder, 512-dim, 256×256 (40 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [{
-			id: "embedding",
-			name: "CLIP Embedding"
-		}],
-		preprocessMode: "resize",
-		inputNormalization: "none",
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s0/onnx/camstack-mobileclip-s0-vision.onnx"),
-				sizeMB: 40
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s0/openvino/camstack-mobileclip-s0-vision.xml"), 25),
-			coreml: {
-				url: hf("clip/mobileclip-s0/coreml/camstack-mobileclip-s0-vision.mlpackage"),
-				sizeMB: 30,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			}
-		}
+var CLIP_EMBEDDING_MODELS = [{
+	id: "mobileclip-s1",
+	name: "MobileCLIP S1",
+	description: "MobileCLIP S1 — Apple balanced CLIP vision encoder, 512-dim, 256×256 (fp16 OpenVINO/CoreML)",
+	inputSize: {
+		width: 256,
+		height: 256
 	},
-	{
-		id: "mobileclip-s1",
-		name: "MobileCLIP S1",
-		description: "MobileCLIP S1 — Apple balanced CLIP vision encoder, 512-dim, 256×256 (90 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [{
-			id: "embedding",
-			name: "CLIP Embedding"
-		}],
-		preprocessMode: "resize",
-		inputNormalization: "none",
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s1/onnx/camstack-mobileclip-s1-vision.onnx"),
-				sizeMB: 90
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s1/openvino/camstack-mobileclip-s1-vision.xml"), 55),
-			coreml: {
-				url: hf("clip/mobileclip-s1/coreml/camstack-mobileclip-s1-vision.mlpackage"),
-				sizeMB: 65,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			}
+	labels: [{
+		id: "embedding",
+		name: "CLIP Embedding"
+	}],
+	preprocessMode: "resize",
+	inputNormalization: "none",
+	formats: {
+		openvino: ovFormat(hf("clip/mobileclip-s1/openvino/camstack-mobileclip-s1-vision.xml"), 55),
+		coreml: {
+			url: hf("clip/mobileclip-s1/coreml/camstack-mobileclip-s1-vision.mlpackage"),
+			sizeMB: 65,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
 		}
+	}
+}, {
+	id: "mobileclip-s2",
+	name: "MobileCLIP S2",
+	description: "MobileCLIP S2 — Apple high-accuracy CLIP vision encoder, 512-dim, 256×256 (fp16 OpenVINO/CoreML)",
+	inputSize: {
+		width: 256,
+		height: 256
 	},
-	{
-		id: "mobileclip-s2",
-		name: "MobileCLIP S2",
-		description: "MobileCLIP S2 — Apple high-accuracy CLIP vision encoder, 512-dim, 256×256 (150 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [{
-			id: "embedding",
-			name: "CLIP Embedding"
-		}],
-		preprocessMode: "resize",
-		inputNormalization: "none",
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s2/onnx/camstack-mobileclip-s2-vision.onnx"),
-				sizeMB: 150
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s2/openvino/camstack-mobileclip-s2-vision.xml"), 90),
-			coreml: {
-				url: hf("clip/mobileclip-s2/coreml/camstack-mobileclip-s2-vision.mlpackage"),
-				sizeMB: 110,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			}
+	labels: [{
+		id: "embedding",
+		name: "CLIP Embedding"
+	}],
+	preprocessMode: "resize",
+	inputNormalization: "none",
+	formats: {
+		openvino: ovFormat(hf("clip/mobileclip-s2/openvino/camstack-mobileclip-s2-vision.xml"), 90),
+		coreml: {
+			url: hf("clip/mobileclip-s2/coreml/camstack-mobileclip-s2-vision.mlpackage"),
+			sizeMB: 110,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
 		}
 	}
-];
+}];
 var AUDIO_CLASSIFIER_MODELS = [{
 	id: "yamnet-onnx",
 	name: "YAMNet",
@@ -1533,7 +1523,7 @@ var PackageDetectionStep = class extends PipelineStepBase {
 			type: "slider",
 			key: "minConfidencePackage",
 			label: "Min Confidence — Package",
-			description: "Drop package predictions below this score. Raise it when static porch furniture (a doormat, a plant pot) is reported as a parcel — those sit just above the default.",
+			description: "Drop package predictions below this score. NOTE: raising it does NOT fix a recurring static false positive — measured on device 615, the false object (a streetlight light patch) scored up to 0.877 while the one real parcel scored 0.885, so no threshold separates them. The lever that does is the package SIZE ceiling in the camera’s Package detection settings (the false object covers 8–9.5% of the frame, real parcels 1–2%).",
 			min: 0,
 			max: 1,
 			step: .05,
@@ -1560,6 +1550,7 @@ var ClassifierWithMinConfidence = class extends PipelineStepBase {
 var PLATE_OCR_DEFAULT_REGION = "DE";
 var PLATE_OCR_DEFAULT_MIN_TEXT_LENGTH = 3;
 var PLATE_OCR_DEFAULT_MIN_TEXT_CONFIDENCE = 0;
+var PLATE_OCR_DEFAULT_MIN_CHAR_PROBABILITY = .75;
 /**
 * Plate OCR step — exposes a `rectify` toggle (default ON) that deskews the
 * plate crop (rotation rectification) before the CTC recognizer reads it.
@@ -1647,6 +1638,7 @@ var STEP_FACE_EMBEDDING = new FaceEmbeddingStep({
 	labelTier: 2,
 	models: [...FACE_EMBEDDING_MODELS],
 	defaultModelId: "arcface-r100",
+	modelScope: "cluster",
 	defaultConfidence: 0,
 	cadence: {
 		trigger: "improve",
@@ -1668,6 +1660,7 @@ var STEP_CLIP_EMBEDDING = new PipelineStepBase({
 	outputClasses: ["embedding"],
 	models: [...CLIP_EMBEDDING_MODELS],
 	defaultModelId: "mobileclip-s1",
+	modelScope: "cluster",
 	enabledByDefault: true,
 	backfillIntoExistingOverrides: true,
 	defaultConfidence: 0,
@@ -1703,12 +1696,13 @@ var STEP_PLATE_OCR = new PlateOcrStep({
 	outputClasses: ["plate-text"],
 	labelTier: 2,
 	models: [...PLATE_OCR_MODELS],
-	defaultModelId: "vgg-english-g2",
+	defaultModelId: "cct-s-v2-global",
 	defaultConfidence: 0,
 	charset: [...VGG_G2_CHARSET],
 	plateRegion: PLATE_OCR_DEFAULT_REGION,
 	minTextLength: PLATE_OCR_DEFAULT_MIN_TEXT_LENGTH,
 	minTextConfidence: PLATE_OCR_DEFAULT_MIN_TEXT_CONFIDENCE,
+	minCharProbability: PLATE_OCR_DEFAULT_MIN_CHAR_PROBABILITY,
 	cadence: {
 		trigger: "once",
 		maxPerTrack: 5