@camstack/addon-post-analysis 1.2.104 → 1.2.107

package/dist/{dist-KXhjlCmh.js → dist-wQmgHP6h.js}

@@ -7821,7 +7821,7 @@ var RecordingBandSchema = object({
 * visit is derived, not a second copy of the files.
 */
 var VISIT_MERGE_GAP_MS = {
-	preBufferSec: 10,
+	preBufferSec: 15,
 	postBufferSec: 30
 }.postBufferSec * 1e3;
 /**
@@ -17239,7 +17239,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.).
@@ -17534,6 +17534,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.
@@ -19330,6 +19359,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
@@ -20205,6 +20254,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(),
@@ -20235,7 +20290,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(),
@@ -25156,7 +25221,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. */
@@ -25199,7 +25269,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
@@ -25220,8 +25325,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(),
@@ -38916,6 +39026,140 @@ function readTimelapseGeneratedAt(rule, deviceId) {
 	if (map !== void 0) return map[String(deviceId)] ?? 0;
 	return rule.lastGeneratedAt ?? 0;
 }
+/**
+* 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);
+}
 object({
 	/**
 	* Fraction of the box's own size added on EACH side before cutting.
@@ -38936,10 +39180,39 @@ 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;
+};
+/**
+* The normalised box that means "the image IS the subject".
+*
+* Used when the stored pixels are ALREADY the model's input — the 112×112
+* aligned face template a gallery sample carries. There is no rectangle left to
+* choose, and the convention must not choose one: re-detecting and re-aligning
+* over a template applies a SECOND warp, passes every gate, and produces a
+* plausible useless vector (session 2026-08-20 §3).
+*
+* Sending it as the whole frame with this box is exact rather than merely
+* convenient, and the reason is a property of {@link deriveDetailCropRect}, not
+* a coincidence: padding a full-frame box can only push OUTSIDE the frame, and
+* both edge modes bring it straight back — unsquared truncates, squared cannot
+* exceed the frame's short side and then slides inside. So for a SQUARE image
+* the derivation is the identity under every convention value, and an operator
+* changing the crop margin cannot silently re-cut an enrolled template.
+* `face-reembed-pass.spec.ts` asserts that identity against the real function.
+*/
+var FULL_IMAGE_BBOX = 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.
 *
@@ -39407,6 +39680,12 @@ Object.defineProperty(exports, "BaseDevice", {
 		return BaseDevice;
 	}
 });
+Object.defineProperty(exports, "CLUSTER_MODEL_SCOPED_STEPS", {
+	enumerable: true,
+	get: function() {
+		return CLUSTER_MODEL_SCOPED_STEPS;
+	}
+});
 Object.defineProperty(exports, "DEFAULT_EVENT_COLOR", {
 	enumerable: true,
 	get: function() {
@@ -39461,6 +39740,12 @@ Object.defineProperty(exports, "EventCategory", {
 		return EventCategory;
 	}
 });
+Object.defineProperty(exports, "FULL_IMAGE_BBOX", {
+	enumerable: true,
+	get: function() {
+		return FULL_IMAGE_BBOX;
+	}
+});
 Object.defineProperty(exports, "LabelAttributionSchema", {
 	enumerable: true,
 	get: function() {
@@ -39863,6 +40148,12 @@ Object.defineProperty(exports, "partialRecord", {
 		return partialRecord;
 	}
 });
+Object.defineProperty(exports, "pickClusterStepModels", {
+	enumerable: true,
+	get: function() {
+		return pickClusterStepModels;
+	}
+});
 Object.defineProperty(exports, "pipelineAnalyticsCapability", {
 	enumerable: true,
 	get: function() {

package/dist/embedding-encoder/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-KXhjlCmh.js");
+const require_dist = require("../dist-wQmgHP6h.js");
 let node_fs = require("node:fs");
 let node_fs$1 = require_dist.__toESM(node_fs, 1);
 node_fs = require_dist.__toESM(node_fs);
@@ -340,139 +340,99 @@ var MLPACKAGE_FILES = [
 	"Data/com.apple.CoreML/model.mlmodel",
 	"Data/com.apple.CoreML/weights/weight.bin"
 ];
-var CLIP_IMAGE_MODELS = [
-	{
-		id: "mobileclip-s0",
-		name: "MobileCLIP S0",
-		description: "Apple MobileCLIP S0 — fast vision encoder, 512-dim, 256×256 (40 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [],
-		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"]
-			}
-		}
+/**
+* NO onnx vision builds, deliberately (2026-08-21). The int8 ONNX vision
+* exports were measured misaligned with the text encoders (matched image↔text
+* cosine ≈ 0.01 vs ≈ 0.22 for the fp16 openvino/coreml builds) — see the
+* catalog note in `addon-pipeline/.../model-catalogs.ts`. The image-encode leg
+* that consumed them here (`embeddingEncoder.encode` → PythonRawTensorEngine)
+* is retired with them: its only caller discarded the vector, and its
+* `preprocessForClip` applied OpenAI mean/std that MobileCLIP never used.
+* S0 was retired the same day (measured worst of the family on fleet crops).
+*/
+var CLIP_IMAGE_MODELS = [{
+	id: "mobileclip-s1",
+	name: "MobileCLIP S1",
+	description: "Apple MobileCLIP S1 — balanced vision encoder, 512-dim, 256×256 (fp16 OpenVINO/CoreML)",
+	inputSize: {
+		width: 256,
+		height: 256
 	},
-	{
-		id: "mobileclip-s1",
-		name: "MobileCLIP S1",
-		description: "Apple MobileCLIP S1 — balanced vision encoder, 512-dim, 256×256 (90 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [],
-		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: [],
+	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: "Apple MobileCLIP S2 — high-accuracy vision encoder, 512-dim, 256×256 (fp16 OpenVINO/CoreML)",
+	inputSize: {
+		width: 256,
+		height: 256
 	},
-	{
-		id: "mobileclip-s2",
-		name: "MobileCLIP S2",
-		description: "Apple MobileCLIP S2 — high-accuracy vision encoder, 512-dim, 256×256 (150 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [],
-		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: [],
+	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 CLIP_TEXT_MODELS = [
-	{
-		id: "mobileclip-s0-text",
-		name: "MobileCLIP S0 Text Encoder",
-		description: "Text encoder for MobileCLIP S0, 512-dim, int8 quantized (35 MB)",
-		inputSize: {
-			width: 0,
-			height: 0
-		},
-		labels: [],
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s0/onnx/camstack-mobileclip-s0-text.onnx"),
-				sizeMB: 35,
-				files: [TOKENIZER_FILE]
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s0/openvino/camstack-mobileclip-s0-text.xml"), 22)
-		}
+}];
+/**
+* The int8 TEXT onnx encoders are healthy — unlike the retired int8 vision
+* exports. Verified 2026-08-21: the live search path (fp16 openvino vision
+* vectors ⋅ int8 onnx text queries) ranks correctly on the real index, and the
+* local cross-check aligns them with the fp16 vision space (cos ≈ 0.22 on
+* matched pairs).
+*/
+var CLIP_TEXT_MODELS = [{
+	id: "mobileclip-s1-text",
+	name: "MobileCLIP S1 Text Encoder",
+	description: "Text encoder for MobileCLIP S1, 512-dim, int8 quantized (61 MB)",
+	inputSize: {
+		width: 0,
+		height: 0
 	},
-	{
-		id: "mobileclip-s1-text",
-		name: "MobileCLIP S1 Text Encoder",
-		description: "Text encoder for MobileCLIP S1, 512-dim, int8 quantized (35 MB)",
-		inputSize: {
-			width: 0,
-			height: 0
+	labels: [],
+	formats: {
+		onnx: {
+			url: hf("clip/mobileclip-s1/onnx/camstack-mobileclip-s1-text.onnx"),
+			sizeMB: 61,
+			files: [TOKENIZER_FILE]
 		},
-		labels: [],
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s1/onnx/camstack-mobileclip-s1-text.onnx"),
-				sizeMB: 35,
-				files: [TOKENIZER_FILE]
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s1/openvino/camstack-mobileclip-s1-text.xml"), 22)
-		}
+		openvino: ovFormat(hf("clip/mobileclip-s1/openvino/camstack-mobileclip-s1-text.xml"), 121)
+	}
+}, {
+	id: "mobileclip-s2-text",
+	name: "MobileCLIP S2 Text Encoder",
+	description: "Text encoder for MobileCLIP S2, 512-dim, int8 quantized (61 MB)",
+	inputSize: {
+		width: 0,
+		height: 0
 	},
-	{
-		id: "mobileclip-s2-text",
-		name: "MobileCLIP S2 Text Encoder",
-		description: "Text encoder for MobileCLIP S2, 512-dim, int8 quantized (35 MB)",
-		inputSize: {
-			width: 0,
-			height: 0
+	labels: [],
+	formats: {
+		onnx: {
+			url: hf("clip/mobileclip-s2/onnx/camstack-mobileclip-s2-text.onnx"),
+			sizeMB: 61,
+			files: [TOKENIZER_FILE]
 		},
-		labels: [],
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s2/onnx/camstack-mobileclip-s2-text.onnx"),
-				sizeMB: 35,
-				files: [TOKENIZER_FILE]
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s2/openvino/camstack-mobileclip-s2-text.xml"), 22)
-		}
+		openvino: ovFormat(hf("clip/mobileclip-s2/openvino/camstack-mobileclip-s2-text.xml"), 121)
 	}
-];
+}];
 //#endregion
 //#region src/embedding-encoder/shared/noop-logger.ts
 var noop = () => {};
@@ -749,14 +709,12 @@ var PythonTextEncoderEngine = class {
 };
 //#endregion
 //#region src/embedding-encoder/addon/clip-models.ts
+/**
+* `mobileclip-s0` was retired on 2026-08-21 (measured worst of the family on
+* real fleet crops). A stored config still naming it resolves to the default
+* via {@link getModelMeta}'s fallback — never to a dangling id.
+*/
 var CLIP_MODEL_META = {
-	"mobileclip-s0": {
-		imageModelId: "mobileclip-s0",
-		textModelId: "mobileclip-s0-text",
-		embeddingDim: 512,
-		inputSize: 256,
-		tokenizerType: "clip"
-	},
 	"mobileclip-s1": {
 		imageModelId: "mobileclip-s1",
 		textModelId: "mobileclip-s1-text",