@camstack/types 1.2.312 → 1.2.314

package/dist/interfaces/config-ui.d.ts

@@ -112,6 +112,13 @@ export interface ConfigFieldModelApplicability {
      * a filter that can never match).
      */
     readonly optionsByModel?: Readonly<Record<string, readonly ConfigOption[]>>;
+    /**
+     * modelId → this field's DEFAULT when that model runs, for a field whose
+     * default belongs to the model (D738: the per-class confidence floors).
+     * Only models whose default differs from the field's own `default` are
+     * listed; a model absent here runs at `default`.
+     */
+    readonly defaultByModel?: Readonly<Record<string, unknown>>;
 }
 export interface ConfigFieldBase {
     readonly key: string;
@@ -143,6 +150,13 @@ export interface ConfigFieldBase {
     readonly secret?: boolean;
     /** Per-model knob applicability — see {@link ConfigFieldModelApplicability}. */
     readonly modelApplicability?: ConfigFieldModelApplicability;
+    /**
+     * An operator value of this field is stored together with the model it was
+     * made for (`<key>ModelId`) and applies only while that model runs; any
+     * other model runs at its own default (D738). Read and written only through
+     * `pipeline/model-bound-settings.ts`.
+     */
+    readonly bindsToModel?: boolean;
     /**
      * Save behavior when value changes.
      * - true: save immediately on change (toggles, selects, checkboxes)

package/dist/pipeline/model-bound-settings.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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.
+ */
+/** `minConfidencePerson` → `minConfidencePersonModelId`. */
+export declare function modelBindingKey(key: string): string;
+/** A loose step-settings bag, as it is stored and travels. */
+export type ModelBoundSettingsBag = Readonly<Record<string, unknown>>;
+/** Where an effective model-bound value came from. */
+export type ModelBoundSettingSource = 'override' | 'model-default' | 'global-default';
+/** An override that is stored but not applied, because another model runs. */
+export interface InapplicableModelBoundOverride {
+    readonly value: unknown;
+    readonly modelId: string;
+}
+/** The effective value of one model-bound field, and why. */
+export interface ModelBoundSettingState {
+    readonly value: unknown;
+    readonly source: ModelBoundSettingSource;
+    /** The model the applied override was made for; absent for a legacy unbound value. */
+    readonly boundModelId?: string;
+    /** A stored override that does NOT apply to the running model. */
+    readonly inapplicableOverride?: InapplicableModelBoundOverride;
+}
+/**
+ * The effective value of `key` for the model that runs (`runningModelId`,
+ * `undefined` when unknown — it then matches no binding).
+ */
+export declare function resolveModelBoundSetting(settings: ModelBoundSettingsBag | undefined, key: string, runningModelId: string | undefined, modelDefault: unknown, globalDefault: unknown): ModelBoundSettingState;
+/**
+ * The OPERATOR layer of a step's settings as the running model sees it: every
+ * model-bound value made for another model is removed (so the default
+ * underneath — the running model's — wins the merge), and every binding key is
+ * stripped. Unbound values are kept. Returns a fresh object; `undefined` stays
+ * `undefined`.
+ */
+export declare function applyModelBoundSettings(settings: ModelBoundSettingsBag | undefined, boundKeys: readonly string[], runningModelId: string | undefined): Record<string, unknown> | undefined;
+/** Store `value` for `key`, made for `modelId`. Returns a fresh object. */
+export declare function writeModelBoundSetting(settings: ModelBoundSettingsBag | undefined, key: string, value: unknown, modelId: string): Record<string, unknown>;
+/** Remove an override and its binding — "reset to the model default". */
+export declare function clearModelBoundSetting(settings: ModelBoundSettingsBag | undefined, key: string): Record<string, unknown>;
+/** True when any of `boundKeys` has an override IN FORCE for `modelId`. */
+export declare function hasModelBoundOverrides(settings: ModelBoundSettingsBag | undefined, boundKeys: readonly string[], modelId: string | undefined): boolean;
+/**
+ * "Reset thresholds to model defaults": remove every override of `boundKeys`
+ * that is in force for `modelId` (bound to it, or unbound), with its binding —
+ * one result, so the editor writes it in one save. An override stored for
+ * ANOTHER model is kept: it is not in force here, and it applies again when
+ * that model runs.
+ */
+export declare function clearModelBoundOverrides(settings: ModelBoundSettingsBag | undefined, boundKeys: readonly string[], modelId: string | undefined): Record<string, unknown>;

package/dist/types/model-variant-groups.d.ts

@@ -69,6 +69,8 @@ export interface ModelVariantTier {
 export interface ModelVariantFamily {
     readonly family: string;
     readonly label: string;
+    /** One short line on what picking this family means, when it is not obvious. */
+    readonly hint?: string;
     readonly tiers: readonly ModelVariantTier[];
 }
 /**

package/dist/types/models.d.ts

@@ -193,6 +193,10 @@ export type ModelLicense = z.infer<typeof ModelLicenseSchema>;
  * - `crop`: the root draws the box the step would have found (`license_plate`
  *   for plate-detection, `face` for face-detection). The box becomes a detail
  *   child of the `parentMacro` detection that contains it — never a track.
+ * - `mask`: the root's decode emits an instance mask with every detection (a
+ *   YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
+ *   detection in the shape that step produces. Derived from the model's
+ *   postprocessor on read, never stored by an import.
  */
 export declare const RootStepSupplySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"label">;
@@ -219,6 +223,11 @@ export declare const RootStepSupplySchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         plate: "plate";
     }>;
     rootInputPx: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"mask">;
+    stepId: z.ZodEnum<{
+        segmentation: "segmentation";
+    }>;
 }, z.core.$strip>], "kind">;
 export type RootStepSupply = z.infer<typeof RootStepSupplySchema>;
 export declare const ModelCatalogEntrySchema: z.ZodObject<{
@@ -310,6 +319,12 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
     }>>;
     postprocessor: z.ZodOptional<z.ZodCustom<PostprocessorType, PostprocessorType>>;
     defaultConfidence: z.ZodOptional<z.ZodNumber>;
+    defaultClassFloors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    gpuInferencePrecision: z.ZodOptional<z.ZodEnum<{
+        f32: "f32";
+        f16: "f16";
+    }>>;
+    suppliedLabelFloors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     faceAlignment: z.ZodOptional<z.ZodBoolean>;
     extraFiles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
         url: z.ZodString;
@@ -396,6 +411,11 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
             plate: "plate";
         }>;
         rootInputPx: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"mask">;
+        stepId: z.ZodEnum<{
+            segmentation: "segmentation";
+        }>;
     }, z.core.$strip>], "kind">>>>;
     clip: z.ZodOptional<z.ZodObject<{
         textModelId: z.ZodString;
@@ -482,11 +502,11 @@ export declare const ModelConvertMetadataSchema: z.ZodObject<{
     }>>;
     outputFormat: z.ZodEnum<{
         classification: "classification";
+        segmentation: "segmentation";
         yolo: "yolo";
         ssd: "ssd";
         embedding: "embedding";
         ocr: "ocr";
-        segmentation: "segmentation";
     }>;
     faceAlignment: z.ZodOptional<z.ZodBoolean>;
     classMap: z.ZodOptional<z.ZodObject<{
@@ -608,6 +628,12 @@ export declare const ConvertResultSchema: z.ZodObject<{
         }>>;
         postprocessor: z.ZodOptional<z.ZodCustom<PostprocessorType, PostprocessorType>>;
         defaultConfidence: z.ZodOptional<z.ZodNumber>;
+        defaultClassFloors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        gpuInferencePrecision: z.ZodOptional<z.ZodEnum<{
+            f32: "f32";
+            f16: "f16";
+        }>>;
+        suppliedLabelFloors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         faceAlignment: z.ZodOptional<z.ZodBoolean>;
         extraFiles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
             url: z.ZodString;
@@ -694,6 +720,11 @@ export declare const ConvertResultSchema: z.ZodObject<{
                 plate: "plate";
             }>;
             rootInputPx: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"mask">;
+            stepId: z.ZodEnum<{
+                segmentation: "segmentation";
+            }>;
         }, z.core.$strip>], "kind">>>>;
         clip: z.ZodOptional<z.ZodObject<{
             textModelId: z.ZodString;

package/dist/types/pipeline-step.d.ts

@@ -251,6 +251,11 @@ export interface PoolModelConfig {
      * `ModelCatalogEntry.outputProbabilities`.
      */
     readonly outputProbabilities?: boolean;
+    /**
+     * OpenVINO GPU inference precision the model needs (`INFERENCE_PRECISION_HINT`,
+     * GPU only). See `ModelCatalogEntry.gpuInferencePrecision`. Absent ⇒ device default.
+     */
+    readonly gpuInferencePrecision?: 'f32' | 'f16';
     /** Postprocessor to apply to raw output in Python */
     readonly postprocessor: PostprocessorType;
     /** Confidence threshold for NMS / filtering */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.312",
+  "version": "1.2.314",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",