@camstack/system 1.2.365 → 1.2.366

package/dist/{dist-BIGk6VLF.mjs → dist-BUfYKaXx.mjs}

@@ -7930,6 +7930,40 @@ var ModelFormatEntrySchema = z.object({
 	revision: z.string().min(1).optional()
 });
 /**
+* What a node holds for one (model, format) (D746). `current` is a complete
+* copy at its catalog revision — exactly what `downloaded: true` means.
+* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
+* no or a different revision record, or a missing sibling. `missing` is no
+* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
+* reclaimable bytes and a copy about to be replaced.
+*/
+var ModelOnDiskStateSchema = z.enum([
+	"current",
+	"stale",
+	"missing"
+]);
+/**
+* The numeric precision of one format's BUILD (D746) — reported only when the
+* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
+* CamStack Core ML export). Absent means "not stated", never "fp32".
+*/
+var ModelFormatPrecisionSchema = z.enum([
+	"fp32",
+	"fp16",
+	"int8"
+]);
+/**
+* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
+* `onDisk` / `precision` are optional for version skew: a runner that predates
+* them omits them, and a reader falls back to `downloaded`.
+*/
+var PipelineModelFormatStatusSchema = z.object({
+	downloaded: z.boolean(),
+	sizeMB: z.number(),
+	onDisk: ModelOnDiskStateSchema.optional(),
+	precision: ModelFormatPrecisionSchema.optional()
+});
+/**
 * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
 * The downloader fetches from `url` and saves to `{modelsDir}/{filename}`.
 */
@@ -25969,7 +26003,7 @@ var FrameRefSchema = z.object({
 	timestamp: z.number(),
 	capturedAt: z.number().optional()
 });
-var ModelFormatSchema$1 = z.enum([
+var ModelFormatSchema$2 = z.enum([
 	"onnx",
 	"coreml",
 	"openvino",
@@ -25987,7 +26021,7 @@ var PipelineSlotSchema = z.enum([
 var PipelineEngineChoiceSchema = z.object({
 	runtime: z.literal("python"),
 	backend: z.string(),
-	format: ModelFormatSchema$1,
+	format: ModelFormatSchema$2,
 	device: z.string().optional()
 });
 /**
@@ -26045,10 +26079,7 @@ var PipelineTemplateSchema$1 = z.object({
 var PipelineModelOptionSchema = z.object({
 	id: z.string(),
 	name: z.string(),
-	formats: z.record(z.string(), z.object({
-		downloaded: z.boolean(),
-		sizeMB: z.number()
-	})),
+	formats: z.record(z.string(), PipelineModelFormatStatusSchema),
 	group: ModelVariantGroupSchema.optional(),
 	legacy: z.boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
@@ -26263,6 +26294,32 @@ var pipelineExecutorCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Best settings (D745): the MODEL-BOUND thresholds (`bindsToModel` keys of
+		* the object-detection root, and their binding keys) stored in THIS node's
+		* per-camera detector settings — and, unless `dryRun`, remove them so the
+		* running model's own defaults apply. Every other key of a camera's store
+		* is kept. `nodeId` is the ROUTING key. `deviceIds` absent ⇒ every camera
+		* with a store. A camera whose store could not be read is `refused`, never
+		* reported as clean.
+		*/
+		clearModelBoundDeviceOverrides: method(z.object({
+			nodeId: z.string(),
+			deviceIds: z.array(z.number()).readonly().optional(),
+			dryRun: z.boolean()
+		}), z.object({
+			entries: z.array(z.object({
+				deviceId: z.number(),
+				keys: z.array(z.string()).readonly()
+			})).readonly(),
+			refused: z.array(z.object({
+				deviceId: z.number(),
+				reason: z.string()
+			})).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Which of THIS node's inference devices the executor currently refuses,
 		* and why. `nodeId` is the ROUTING key (stripped by the generated router).
 		*
@@ -26357,12 +26414,12 @@ var pipelineExecutorCapability = {
 		downloadModel: method(z.object({
 			addonId: z.string(),
 			modelId: z.string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), DownloadModelResultSchema, { kind: "mutation" }),
 		deleteModel: method(z.object({
 			addonId: z.string(),
 			modelId: z.string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), z.object({ success: z.literal(true) }), { kind: "mutation" }),
 		/**
 		* Stateless single-frame execution. Callers (runner, benchmark) pass
@@ -26608,6 +26665,204 @@ var pipelineExecutorCapability = {
 		getDetectionConfigSchema: method(z.void(), ConfigUISchemaNullableBridge)
 	}
 };
+/**
+* The wire shapes of the Best settings plan and apply (D745), used by the
+* `pipeline-orchestrator` cap. The recommender's own types
+* (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
+* schemas are what crosses the cap boundary.
+*/
+var ModelFormatSchema$1 = z.enum(MODEL_FORMATS);
+var HardwareClassIdSchema = z.enum([
+	"intel-core-ultra",
+	"intel-n-series",
+	"apple-m-base",
+	"apple-m-pro",
+	"unknown"
+]);
+var AcceleratorKindSchema = z.enum([
+	"intel-npu",
+	"intel-igpu",
+	"x86-cpu",
+	"arm-cpu",
+	"apple-ane",
+	"coral"
+]);
+var RecommendationReasonSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("fits"),
+		utilisation: z.number()
+	}),
+	z.object({
+		kind: z.literal("tie-faster"),
+		over: z.string(),
+		recallDelta: z.number()
+	}),
+	z.object({
+		kind: z.literal("stepped-down"),
+		from: z.string(),
+		to: z.string(),
+		limitedBy: z.string()
+	}),
+	z.object({
+		kind: z.literal("no-fit-lightest"),
+		utilisation: z.number()
+	}),
+	z.object({
+		kind: z.literal("derived-latency"),
+		modelId: z.string()
+	}),
+	z.object({
+		kind: z.literal("estimated-load"),
+		observedForMs: z.number().nullable()
+	}),
+	z.object({ kind: z.literal("cpu-device") }),
+	z.object({ kind: z.literal("coral-untouched") }),
+	z.object({ kind: z.literal("device-disabled") }),
+	z.object({ kind: z.literal("device-unavailable") }),
+	z.object({ kind: z.literal("node-offline") }),
+	z.object({ kind: z.literal("no-hardware-facts") }),
+	z.object({
+		kind: z.literal("no-measured-data"),
+		hardwareClass: HardwareClassIdSchema
+	}),
+	z.object({
+		kind: z.literal("no-family-build"),
+		format: ModelFormatSchema$1
+	})
+]);
+var DeviceDemandSchema = z.object({
+	nodeId: z.string(),
+	deviceKey: z.string(),
+	demandFps: z.number(),
+	maxCameraFps: z.number(),
+	alwaysOnCameras: z.number(),
+	onMotionSessions: z.number(),
+	onMotionSource: z.enum([
+		"observed-24h",
+		"estimate",
+		"none"
+	]),
+	observedForMs: z.number().nullable()
+});
+var DeviceModelChoiceSchema = z.object({
+	modelId: z.string(),
+	p50Ms: z.number(),
+	fps: z.number(),
+	measured: z.boolean(),
+	utilisation: z.number(),
+	personRecall: z.number()
+});
+var DeviceRecommendationSchema = z.object({
+	deviceKey: z.string(),
+	accelerator: AcceleratorKindSchema.nullable(),
+	enabled: z.boolean(),
+	available: z.boolean(),
+	demand: DeviceDemandSchema.nullable(),
+	chosen: DeviceModelChoiceSchema.nullable(),
+	reasons: z.array(RecommendationReasonSchema).readonly()
+});
+var NodeRecommendationSchema = z.object({
+	nodeId: z.string(),
+	reachable: z.boolean(),
+	hardwareClass: HardwareClassIdSchema.nullable(),
+	cpuModel: z.string().nullable(),
+	skipped: z.boolean(),
+	acceleratorModelId: z.string().nullable(),
+	devices: z.array(DeviceRecommendationSchema).readonly(),
+	reasons: z.array(RecommendationReasonSchema).readonly()
+});
+var ModelPinChangeSchema = z.object({
+	stepId: z.string(),
+	before: z.string().nullable(),
+	after: z.string().nullable()
+});
+var NodeDeviceChangeSchema = z.object({
+	nodeId: z.string(),
+	deviceKey: z.string(),
+	madeExplicit: z.boolean(),
+	modelPins: z.array(ModelPinChangeSchema).readonly(),
+	thresholds: z.array(z.object({
+		stepId: z.string(),
+		keys: z.array(z.string()).readonly()
+	})).readonly()
+});
+var CameraOverrideClearSchema = z.object({
+	deviceId: z.number(),
+	source: z.enum(["step-override", "wholesale"]),
+	nodeId: z.string(),
+	deviceKey: z.string().nullable(),
+	stepId: z.string(),
+	modelIdBefore: z.string().nullable(),
+	keys: z.array(z.string()).readonly()
+});
+var DetectorStoreClearSchema = z.object({
+	deviceId: z.number(),
+	keys: z.array(z.string()).readonly()
+});
+var BestSettingsWarningSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("detector-store-cluster-wide"),
+		skippedNodes: z.array(z.string()).readonly()
+	}),
+	z.object({
+		kind: z.literal("detector-store-unreadable"),
+		error: z.string()
+	}),
+	z.object({
+		kind: z.literal("coral-enabled"),
+		nodeId: z.string(),
+		deviceKey: z.string()
+	})
+]);
+var BestSettingsOptionsSchema = z.object({ 
+/** Share of each accelerator's throughput kept free (0.3–0.5). */
+headroom: z.number().min(.3).max(.5).default(.4) });
+var BestSettingsPlanSchema = z.object({
+	/** Hash of everything the apply will write — the apply refuses a different one. */
+	planHash: z.string(),
+	family: z.literal("yolov9"),
+	headroom: z.number(),
+	generatedAt: z.number(),
+	nodes: z.array(NodeRecommendationSchema).readonly(),
+	nodeChanges: z.array(NodeDeviceChangeSchema).readonly(),
+	cameraClears: z.array(CameraOverrideClearSchema).readonly(),
+	detectorStoreClears: z.array(DetectorStoreClearSchema).readonly(),
+	warnings: z.array(BestSettingsWarningSchema).readonly()
+});
+var BestSettingsApplyInputSchema = z.object({
+	planHash: z.string(),
+	headroom: z.number().min(.3).max(.5).default(.4)
+});
+var BestSettingsPhaseResultSchema = z.object({
+	phase: z.enum([
+		"download",
+		"camera-overrides",
+		"detector-thresholds",
+		"node-models",
+		"redispatch"
+	]),
+	ok: z.boolean(),
+	detail: z.string()
+});
+var BestSettingsApplyResultSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("applied"),
+		planHash: z.string(),
+		phases: z.array(BestSettingsPhaseResultSchema).readonly()
+	}),
+	z.object({
+		kind: z.literal("aborted"),
+		phases: z.array(BestSettingsPhaseResultSchema).readonly()
+	}),
+	z.object({
+		kind: z.literal("stale"),
+		plan: BestSettingsPlanSchema
+	}),
+	z.object({
+		kind: z.literal("refused"),
+		reason: z.enum(["apply-in-progress"])
+	})
+]);
 z.object({
 	activeCameras: z.number(),
 	throttledCameras: z.number(),
@@ -28828,6 +29083,27 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Best settings (D745) — DRY RUN. Recommends ONE detector family (YOLOv9)
+		* for the whole cluster from each node's static hardware class, the
+		* measured latency table and the detection demand, and lists every write
+		* the apply would make: the node model pins set, the enrichment pins and
+		* model-bound thresholds removed (node level and per camera), and the
+		* per-camera detector thresholds cleared. Writes nothing. Step
+		* enablement, device enablement, pins, recording, notifications, zones and
+		* rules are never part of it. `planHash` names exactly this diff.
+		*/
+		planBestSettings: method(BestSettingsOptionsSchema, BestSettingsPlanSchema, { auth: "admin" }),
+		/**
+		* Best settings (D745) — APPLY the plan the operator confirmed. Recomputes
+		* the plan and refuses (`stale`, with the fresh plan) when its hash is not
+		* `planHash`, so what is written is exactly the confirmed diff. Offline
+		* nodes are skipped; there is no undo.
+		*/
+		applyBestSettings: method(BestSettingsApplyInputSchema, BestSettingsApplyResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: method(z.object({ deviceId: z.number() }), CameraPipelineSettingsSchema.nullable()),
 		/** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
@@ -51788,6 +52064,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineExecutor.clearModelBoundDeviceOverrides": {
+		capName: "pipeline-executor",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineExecutor.deleteModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -52004,6 +52286,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.applyBestSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.applyDeviceSettingsPatch": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -52178,6 +52466,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.planBestSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.rebalance": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -57855,6 +58149,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineExecutor.clearModelBoundDeviceOverrides": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineExecutor.runPipeline": [{
 		name: "deviceId",
 		form: "single",