@camstack/addon-pipeline 1.2.339 → 1.2.341

package/dist/{dist-BUqvRc-c.js → dist-PiNPe8uQ.js}

@@ -12943,6 +12943,40 @@ var ModelFormatEntrySchema = object({
 	revision: 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 = _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 = _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 = object({
+	downloaded: boolean(),
+	sizeMB: 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}`.
 */
@@ -26539,7 +26573,7 @@ var FrameRefSchema = object({
 	timestamp: number(),
 	capturedAt: number().optional()
 });
-var ModelFormatSchema$1 = _enum([
+var ModelFormatSchema$2 = _enum([
 	"onnx",
 	"coreml",
 	"openvino",
@@ -26557,7 +26591,7 @@ var PipelineSlotSchema = _enum([
 var PipelineEngineChoiceSchema = object({
 	runtime: literal("python"),
 	backend: string(),
-	format: ModelFormatSchema$1,
+	format: ModelFormatSchema$2,
 	device: string().optional()
 });
 /**
@@ -26614,10 +26648,7 @@ var PipelineTemplateSchema$1 = object({
 var PipelineModelOptionSchema = object({
 	id: string(),
 	name: string(),
-	formats: record(string(), object({
-		downloaded: boolean(),
-		sizeMB: number()
-	})),
+	formats: record(string(), PipelineModelFormatStatusSchema),
 	group: ModelVariantGroupSchema.optional(),
 	legacy: boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
@@ -26832,6 +26863,32 @@ var pipelineExecutorCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Auto tune (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(object({
+			nodeId: string(),
+			deviceIds: array(number()).readonly().optional(),
+			dryRun: boolean()
+		}), object({
+			entries: array(object({
+				deviceId: number(),
+				keys: array(string()).readonly()
+			})).readonly(),
+			refused: array(object({
+				deviceId: number(),
+				reason: 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).
 		*
@@ -26926,12 +26983,12 @@ var pipelineExecutorCapability = {
 		downloadModel: method(object({
 			addonId: string(),
 			modelId: string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), DownloadModelResultSchema, { kind: "mutation" }),
 		deleteModel: method(object({
 			addonId: string(),
 			modelId: string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), object({ success: literal(true) }), { kind: "mutation" }),
 		/**
 		* Stateless single-frame execution. Callers (runner, benchmark) pass
@@ -27177,6 +27234,352 @@ var pipelineExecutorCapability = {
 		getDetectionConfigSchema: method(_void(), ConfigUISchemaNullableBridge)
 	}
 };
+/**
+* Wire shapes of the Load balancing surface (D748): the session placement
+* policy, the atomic share write, the observed placement statistics, the
+* hardware share suggestion and the stale device pins.
+*/
+/**
+* How a new detection session picks its node and device.
+*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
+*    constant node order at a tie (D37). An idle node always ties at 0, so a
+*    weight only bites once a node already holds a session.
+*  - `share` — the share of PARALLEL sessions is held to the weights, and a
+*    full or drowning node yields to a free one (D748).
+*/
+var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
+var LoadBalancingSharesInputSchema = object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: record(string(), number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: record(string(), record(string(), number().positive())).default({})
+});
+var PlacementStatsInputSchema = object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = object({
+	deviceKey: string(),
+	/** Sessions running on this device now. */
+	sessionsNow: number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: number().nullable()
+});
+var PlacementNodeStatsSchema = object({
+	nodeId: string(),
+	sessionsNow: number(),
+	sessionsStarted: number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: number(),
+	devices: array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = object({
+	deviceId: number(),
+	deviceKey: string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: _enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: number(),
+	sessionsNow: number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: number(),
+	nodes: array(PlacementNodeStatsSchema).readonly(),
+	stalePins: array(StaleDevicePinSchema).readonly()
+});
+var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
+var SuggestedDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Share of the node (0–100, rounded). */
+	share: number(),
+	modelId: string().nullable(),
+	/** Inferences per second at that model, from the measured table. */
+	fps: number().nullable(),
+	measured: boolean(),
+	/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
+	suggestedMaxSessions: number().nullable()
+});
+var SuggestedNodeShareSchema = object({
+	nodeId: string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: number(),
+	devices: array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: string().nullable()
+});
+var SuggestSharesResultSchema = object({
+	headroom: number(),
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: number(),
+	/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
+	iterations: number(),
+	nodes: array(SuggestedNodeShareSchema).readonly()
+});
+/**
+* Where the node and device shares come from (D750).
+*  - `auto` — computed by the system from the cluster's measured capacity at
+*    the Auto tune models, and recomputed whenever a node or device joins,
+*    leaves, is switched on or off, or changes model.
+*  - `manual` — the operator's stored sliders. A node or device that cannot
+*    take sessions gives its share to the others in proportion; the stored
+*    values are never rewritten for that.
+*/
+var ShareSourceSchema = _enum(["auto", "manual"]);
+var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
+object({
+	nodes: record(string(), number()),
+	devices: record(string(), record(string(), number()))
+});
+var EffectiveDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Can take sessions now (enabled, available, can run the root). */
+	eligible: boolean(),
+	/** The share the source assigns, as a percentage of the node's devices. */
+	configuredPct: number(),
+	/** The share actually used, after an ineligible device's share went to the others. */
+	effectivePct: number()
+});
+var EffectiveNodeShareSchema = object({
+	nodeId: string(),
+	eligible: boolean(),
+	configuredPct: number(),
+	effectivePct: number(),
+	devices: array(EffectiveDeviceShareSchema).readonly()
+});
+var EffectiveSharesSchema = object({
+	source: ShareSourceSchema,
+	policy: SessionPlacementPolicySchema,
+	/** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
+	autoPending: boolean(),
+	/** When the automatic shares were last computed (ms epoch); null = never. */
+	computedAt: number().nullable(),
+	/** What made the system recompute them last. */
+	trigger: string().nullable(),
+	nodes: array(EffectiveNodeShareSchema).readonly(),
+	/** The relative weights the election reads (before eligibility). */
+	nodeWeights: record(string(), number()),
+	deviceWeights: record(string(), record(string(), number()))
+});
+/**
+* The wire shapes of the Auto tune 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 = _enum(MODEL_FORMATS);
+var HardwareClassIdSchema = _enum([
+	"intel-core-ultra",
+	"intel-n-series",
+	"apple-m-base",
+	"apple-m-pro",
+	"unknown"
+]);
+var AcceleratorKindSchema = _enum([
+	"intel-npu",
+	"intel-igpu",
+	"x86-cpu",
+	"arm-cpu",
+	"apple-ane",
+	"coral"
+]);
+var RecommendationReasonSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("fits"),
+		utilisation: number()
+	}),
+	object({
+		kind: literal("tie-faster"),
+		over: string(),
+		recallDelta: number()
+	}),
+	object({
+		kind: literal("stepped-down"),
+		from: string(),
+		to: string(),
+		limitedBy: string()
+	}),
+	object({
+		kind: literal("no-fit-lightest"),
+		utilisation: number()
+	}),
+	object({
+		kind: literal("derived-latency"),
+		modelId: string()
+	}),
+	object({
+		kind: literal("estimated-load"),
+		observedForMs: number().nullable()
+	}),
+	object({ kind: literal("cpu-device") }),
+	object({ kind: literal("coral-untouched") }),
+	object({ kind: literal("device-disabled") }),
+	object({ kind: literal("device-unavailable") }),
+	object({ kind: literal("node-offline") }),
+	object({ kind: literal("no-hardware-facts") }),
+	object({
+		kind: literal("no-measured-data"),
+		hardwareClass: HardwareClassIdSchema
+	}),
+	object({
+		kind: literal("no-family-build"),
+		format: ModelFormatSchema$1
+	})
+]);
+var DeviceDemandSchema = object({
+	nodeId: string(),
+	deviceKey: string(),
+	demandFps: number(),
+	maxCameraFps: number(),
+	alwaysOnCameras: number(),
+	onMotionSessions: number(),
+	onMotionSource: _enum([
+		"observed-24h",
+		"estimate",
+		"none"
+	]),
+	observedForMs: number().nullable(),
+	/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
+	placement: SessionPlacementPolicySchema
+});
+var DeviceModelChoiceSchema = object({
+	modelId: string(),
+	p50Ms: number(),
+	fps: number(),
+	measured: boolean(),
+	utilisation: number(),
+	personRecall: number()
+});
+var DeviceRecommendationSchema = object({
+	deviceKey: string(),
+	accelerator: AcceleratorKindSchema.nullable(),
+	enabled: boolean(),
+	available: boolean(),
+	demand: DeviceDemandSchema.nullable(),
+	chosen: DeviceModelChoiceSchema.nullable(),
+	reasons: array(RecommendationReasonSchema).readonly()
+});
+var NodeRecommendationSchema = object({
+	nodeId: string(),
+	reachable: boolean(),
+	hardwareClass: HardwareClassIdSchema.nullable(),
+	cpuModel: string().nullable(),
+	skipped: boolean(),
+	acceleratorModelId: string().nullable(),
+	devices: array(DeviceRecommendationSchema).readonly(),
+	reasons: array(RecommendationReasonSchema).readonly()
+});
+var ModelPinChangeSchema = object({
+	stepId: string(),
+	before: string().nullable(),
+	after: string().nullable()
+});
+var NodeDeviceChangeSchema = object({
+	nodeId: string(),
+	deviceKey: string(),
+	madeExplicit: boolean(),
+	modelPins: array(ModelPinChangeSchema).readonly(),
+	thresholds: array(object({
+		stepId: string(),
+		keys: array(string()).readonly()
+	})).readonly()
+});
+var CameraOverrideClearSchema = object({
+	deviceId: number(),
+	source: _enum(["step-override", "wholesale"]),
+	nodeId: string(),
+	deviceKey: string().nullable(),
+	stepId: string(),
+	modelIdBefore: string().nullable(),
+	keys: array(string()).readonly()
+});
+var DetectorStoreClearSchema = object({
+	deviceId: number(),
+	keys: array(string()).readonly()
+});
+var AutoTuneWarningSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("detector-store-cluster-wide"),
+		skippedNodes: array(string()).readonly()
+	}),
+	object({
+		kind: literal("detector-store-unreadable"),
+		error: string()
+	}),
+	object({
+		kind: literal("coral-enabled"),
+		nodeId: string(),
+		deviceKey: string()
+	})
+]);
+var AutoTuneOptionsSchema = object({
+	/** Share of each accelerator's throughput kept free (0.3–0.5). */
+	headroom: number().min(.3).max(.5).default(.4),
+	/**
+	* What-if shares (D748): plan as if these node/device shares were stored
+	* and the policy were `share`. Absent = the stored shares under the stored
+	* policy. A what-if plan is for display; apply always re-plans from what
+	* is stored.
+	*/
+	shares: LoadBalancingSharesInputSchema.optional()
+});
+var AutoTunePlanSchema = object({
+	/** Hash of everything the apply will write — the apply refuses a different one. */
+	planHash: string(),
+	family: literal("yolov9"),
+	headroom: number(),
+	/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
+	whatIf: boolean(),
+	generatedAt: number(),
+	nodes: array(NodeRecommendationSchema).readonly(),
+	nodeChanges: array(NodeDeviceChangeSchema).readonly(),
+	cameraClears: array(CameraOverrideClearSchema).readonly(),
+	detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
+	warnings: array(AutoTuneWarningSchema).readonly()
+});
+var AutoTuneApplyInputSchema = object({
+	planHash: string(),
+	headroom: number().min(.3).max(.5).default(.4)
+});
+var AutoTunePhaseResultSchema = object({
+	phase: _enum([
+		"download",
+		"camera-overrides",
+		"detector-thresholds",
+		"node-models",
+		"redispatch"
+	]),
+	ok: boolean(),
+	detail: string()
+});
+var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("applied"),
+		planHash: string(),
+		phases: array(AutoTunePhaseResultSchema).readonly()
+	}),
+	object({
+		kind: literal("aborted"),
+		phases: array(AutoTunePhaseResultSchema).readonly()
+	}),
+	object({
+		kind: literal("stale"),
+		plan: AutoTunePlanSchema
+	}),
+	object({
+		kind: literal("refused"),
+		reason: _enum(["apply-in-progress"])
+	})
+]);
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -28549,7 +28952,6 @@ var CameraStepOverridePatchSchema = object({
 	settings: record(string(), unknown()).readonly().optional()
 });
 var CameraPipelineSettingsSchema = object({
-	pinnedAgentNodeId: string().optional(),
 	stepToggles: record(string(), boolean()).optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
@@ -29048,12 +29450,6 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({
-	agentNodeId: string(),
-	detectWeight: number().positive().nullable()
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
 }), method(object({
 	agentNodeId: string(),
 	detect: boolean().nullable().optional(),
@@ -29095,6 +29491,15 @@ method(object({
 }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
 	deviceId: number(),
 	addonId: string(),
@@ -41168,6 +41573,8 @@ Object.freeze({
 	vehicle: .65,
 	animal: .65
 });
+var HF_REPO = "camstack/camstack-models";
+`${HF_REPO}`;
 /**
 * Accessory device helpers — shared across drivers.
 *
@@ -45704,6 +46111,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineExecutor.clearModelBoundDeviceOverrides": {
+		capName: "pipeline-executor",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineExecutor.deleteModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -45920,6 +46333,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.applyAutoTune": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.applyDeviceSettingsPatch": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46034,6 +46453,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getEffectiveShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getGlobalMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46070,6 +46495,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getPlacementStats": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getReconcileFromDiskStatus": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46094,6 +46525,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.planAutoTune": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.rebalance": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46154,12 +46591,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentDetectWeight": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -46214,12 +46645,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setLoadBalancingShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setPipelineDevicePin": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setShareSource": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineOrchestrator.suggestShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.unassignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -51516,6 +51965,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineExecutor.clearModelBoundDeviceOverrides": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineExecutor.runPipeline": [{
 		name: "deviceId",
 		form: "single",
@@ -53422,41 +53876,6 @@ function stepModelRunsOnFormat(models, modelId, format) {
 	}
 	return models.some((m) => m.legacy !== true && hasBuild(m, format));
 }
-/**
-* Model-bound step settings (D738): an operator value that is only meaningful
-* for ONE model, stored together with that model's id.
-*
-* The per-class confidence floors are the case it exists for. A score is a
-* property of one detector's output scale — on this hub the median score of a
-* correct person was 0.78 on `yolov9m-320-int8`, 0.68 on `yolo26s-320-int8`,
-* 0.40 on `yolo26n-320-int8` and 0.89 on `yolo26s` (640) — so a floor tuned on
-* one model is wrong on the next. The DEFAULT of such a field belongs to the
-* model (the catalog entry); an operator OVERRIDE belongs to the model it was
-* made for.
-*
-* The binding is checked at READ time against the model that RUNS, never
-* enforced by a write on the model-change path: a model can change without any
-* operator write at all (an unpinned root follows the elected device's
-* hardware-aware default, D736), and an event-driven reset could be dropped
-* (events are telemetry, D8/D11). So:
-*
-*   effective = override   when the stored binding names the running model
-*             | override   when no binding is stored (a legacy / programmatic
-*                          value — it applies to whatever runs, as before D738)
-*             | the running model's default, when it declares one
-*             | the field's global default.
-*
-* Storage shape: the value stays a plain number under its own key (every
-* reader of the raw settings bag keeps working), and the binding is a SIBLING
-* key, {@link modelBindingKey}. Both are flat so the shallow per-key merges of
-* the settings layers (node fold, camera override) carry a value and its
-* binding together whenever one layer writes both — which every writer here
-* does.
-*
-* Lives in the bare `@camstack/types` entry, which every addon bundles, so the
-* runner (`addon-pipeline`) and the editors (`ui-library`, `addon-admin-ui`)
-* apply the same rule.
-*/
 /** Suffix of the sibling key that names the model a stored value was made for. */
 var MODEL_BINDING_SUFFIX = "ModelId";
 /** `minConfidencePerson` → `minConfidencePersonModelId`. */
@@ -53516,6 +53935,17 @@ function applyModelBoundSettings(settings, boundKeys, runningModelId) {
 	}
 	return out;
 }
+/**
+* The keys of every `bindsToModel` field of a step's config schema, groups
+* flattened (D738). One definition for the runner (which applies the binding)
+* and the orchestrator's Auto tune (which clears those overrides, D745).
+*/
+function collectModelBoundKeys(fields) {
+	return fields.flatMap((field) => {
+		if (field.type === "group") return collectModelBoundKeys(field.fields);
+		return "key" in field && "bindsToModel" in field && field.bindsToModel === true ? [field.key] : [];
+	});
+}
 /** Side of the square, as a multiple of the face box's longer side. */
 var ROOT_FACE_REFINE_SCALE = 1.6;
 /**
@@ -54950,6 +55380,12 @@ Object.defineProperty(exports, "G711_SCALE_CORRECTION_DB", {
 		return G711_SCALE_CORRECTION_DB;
 	}
 });
+Object.defineProperty(exports, "HF_REPO", {
+	enumerable: true,
+	get: function() {
+		return HF_REPO;
+	}
+});
 Object.defineProperty(exports, "LABEL_SUPPLY_MACRO", {
 	enumerable: true,
 	get: function() {
@@ -55154,6 +55590,12 @@ Object.defineProperty(exports, "clipExportFailureOf", {
 		return clipExportFailureOf;
 	}
 });
+Object.defineProperty(exports, "collectModelBoundKeys", {
+	enumerable: true,
+	get: function() {
+		return collectModelBoundKeys;
+	}
+});
 Object.defineProperty(exports, "containingParentIndex", {
 	enumerable: true,
 	get: function() {
@@ -55460,6 +55902,12 @@ Object.defineProperty(exports, "modeMayWrite", {
 		return modeMayWrite;
 	}
 });
+Object.defineProperty(exports, "modelBindingKey", {
+	enumerable: true,
+	get: function() {
+		return modelBindingKey;
+	}
+});
 Object.defineProperty(exports, "motionDetectionCapability", {
 	enumerable: true,
 	get: function() {