@camstack/types 1.1.32 → 1.1.34

package/dist/interfaces/capability.d.ts

@@ -11,10 +11,7 @@ import type { ILogDestination } from './logging.js';
 import type { IPipelineExecutorProvider } from './pipeline-executor-capability.js';
 import type { IPipelineOrchestratorProvider } from './pipeline-orchestrator-capability.js';
 import type { IPipelineRunnerProvider } from './pipeline-runner-capability.js';
-import type { IRestreamer } from './restreamer.js';
 import type { IEmbeddingsBackend, ISettingsBackend } from './storage.js';
-import type { IStreamingEngine } from './streaming.js';
-import type { IWebRtcProvider } from './webrtc-provider.js';
 /**
  * Pipeline step capability — each step is a separate capability
  * named `pipeline-step:{stepId}` (e.g., `pipeline-step:object-detection`).
@@ -119,8 +116,6 @@ export interface CapabilityInfo {
 export interface CapabilityProviderMap {
     storage: InferProvider<typeof import('../capabilities/storage.cap.js').storageCapability>;
     'log-destination': ILogDestination;
-    restreamer: IRestreamer;
-    webrtc: IWebRtcProvider;
     'stream-broker': InferProvider<typeof streamBrokerCapability>;
     'addon-pages': InferProvider<typeof import('../capabilities/addon-pages.cap.js').addonPagesCapability>;
     'addon-pages-source': IAddonPageProvider;
@@ -143,7 +138,6 @@ export interface CapabilityProviderMap {
     alerts: InferProvider<typeof import('../capabilities/alerts.cap.js').alertsCapability>;
     backup: InferProvider<typeof import('../capabilities/backup.cap.js').backupCapability>;
     'network-access': InferProvider<typeof import('../capabilities/network-access.cap.js').networkAccessCapability>;
-    'streaming-engine': IStreamingEngine;
     'advanced-notifier': InferProvider<typeof import('../capabilities/advanced-notifier.cap.js').advancedNotifierCapability>;
     'pipeline-executor': IPipelineExecutorProvider;
     'detection-pipeline': InferProvider<typeof import('../capabilities/detection-pipeline.cap.js').detectionPipelineCapability>;
@@ -159,7 +153,6 @@ export interface CapabilityProviderMap {
     'settings-store': ISettingsBackend;
     embeddings: IEmbeddingsBackend;
     snapshot: ISnapshotOrchestrator;
-    'snapshot-provider': InferProvider<typeof import('../capabilities/snapshot-provider.cap.js').snapshotProviderCapability>;
     'metrics-provider': InferProvider<typeof import('../capabilities/metrics-provider.cap.js').metricsProviderCapability>;
     'camera-streams': InferProvider<typeof import('../capabilities/camera-streams.cap.js').cameraStreamsCapability>;
     'webrtc-session': InferProvider<typeof import('../capabilities/webrtc-session.cap.js').webrtcSessionCapability>;

package/dist/interfaces/event-bus.d.ts

@@ -662,6 +662,15 @@ export interface EventCatalog {
         readonly deviceId: number;
         readonly config: CameraPipelineConfig;
     };
+    /**
+     * Cluster camera-source owner (`clusterRoles.ingestNode`) resolved/changed.
+     * Pushed by addon-pipeline-orchestrator on every node-capability refresh so
+     * the stream-broker gates physical-broker creation on the current owner
+     * without a per-`ensureBroker` `getIngestOwner` query.
+     */
+    'pipeline.ingest-owner-changed': {
+        readonly ownerNodeId: string;
+    };
     /**
      * Periodic per-runner load snapshot (~1 Hz). Replaces UI polling on
      * `pipelineRunner.getLocalLoad`. UI subscribes per agent node.

package/dist/interfaces/pipeline-executor-capability.d.ts

@@ -7,7 +7,7 @@ import type { FrameResult, DetectorOutput } from '../types/detection.js';
 import type { ConfigUISchema } from './config-ui.js';
 import type { InferenceCapabilities } from './inference-capabilities.js';
 import type { IAddonResolver } from './pipeline-runner.js';
-import type { EngineProvisioning } from '../capabilities/pipeline-executor.cap.js';
+import type { EngineProvisioning, PipelineValidationResult } from '../capabilities/pipeline-executor.cap.js';
 /**
  * Step configuration for pipeline execution — no runtime/backend (comes
  * from engine). Phase 7 (settings redesign) removed the generic
@@ -81,6 +81,19 @@ export interface IPipelineExecutorProvider {
     getGlobalSteps(): Promise<PipelineDefaultStep[] | null>;
     /** Get the runner-ready pipeline config */
     getGlobalPipelineConfig(): Promise<PipelineConfig | null>;
+    /**
+     * Gate B (pre-init config-correctness gate). PURE COMPUTE against this
+     * node's `currentEngine.format` — resolves `steps` the same way the
+     * runtime dispatch path would and reports what WOULD happen, WITHOUT
+     * writing any node-global state (the node-default `modelSubstitutions`
+     * map stays owned exclusively by the node-default tree resolver).
+     * Called by the orchestrator at attach time, node-pinned to the target
+     * node, so config problems surface before `pipelineRunner.attachCamera`
+     * rather than at the first per-frame resolve. Never throws.
+     */
+    validatePipeline(input: {
+        readonly steps: readonly PipelineStepInput[];
+    }): Promise<PipelineValidationResult>;
     /** Get the currently selected engine (bootstrap default on the node). */
     getSelectedEngine(): Promise<PipelineEngineChoice>;
     /**

package/dist/interfaces/pipeline-runner-capability.d.ts

@@ -1,5 +1,4 @@
 import type { OrchestratorMetrics, CameraMetrics } from './api-shared.js';
-import type { PipelineEngineChoice } from '../types/pipeline.js';
 import type { PipelineStepInputOutput } from '../capabilities/pipeline-executor.cap.js';
 import type { Zone } from '../capabilities/zones.cap.js';
 import type { PipelinePhaseMode } from '../device/device-profile.js';
@@ -8,11 +7,10 @@ import type { PipelinePhaseMode } from '../device/device-profile.js';
  * via `attachCamera`. Carries everything the runner needs to subscribe to
  * the local stream-broker and dispatch frames to motion / detection caps.
  *
- * Stateless-pipeline model: `engine`, `steps`, and `audio` travel with the
- * payload so the runner holds the full content in RAM for the lifetime of
- * the attach. Re-sent on rebalance, edit, or restart. The fields are
- * optional during the additive migration (Phase 1) — the runner treats
- * absent content as "no inference" until Phase 3 makes them required.
+ * Stateless-pipeline model: `steps` and `audio` travel with the payload so
+ * the runner holds the content in RAM for the lifetime of the attach.
+ * Re-sent on rebalance, edit, or restart. Engine is NOT carried: it is
+ * node-local, resolved by the executing runner at dispatch time.
  */
 export interface RunnerCameraConfig {
     readonly deviceId: number;
@@ -24,14 +22,16 @@ export interface RunnerCameraConfig {
     /** Motion sources that can activate the pipeline. At least one entry. */
     readonly motionSources: import('../capabilities/pipeline-runner.cap.js').MotionSources;
     readonly pipelineEnabled: boolean;
-    /** Engine choice for video steps — Phase 1 optional, runner ignores until Phase 3. */
-    readonly engine?: PipelineEngineChoice;
     /** Ordered tree of video steps — Phase 1 optional, runner ignores until Phase 3. */
     readonly steps?: readonly PipelineStepInputOutput[];
-    /** Audio classification branch — Phase 1 optional, runner ignores until Phase 3. */
+    /**
+     * Audio classification branch — Phase 1 optional, runner ignores until
+     * Phase 3. `modelId` absent = model selection is data only; the
+     * executing node resolves its own format default at runtime
+     * (mirrors `CameraPipelineConfig.audio`).
+     */
     readonly audio?: {
-        readonly engine: PipelineEngineChoice;
-        readonly modelId: string;
+        readonly modelId?: string;
         readonly enabled: boolean;
     } | null;
     /**

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

@@ -42,8 +42,8 @@ export declare const RecordingModeSchema: z.ZodEnum<{
 }>;
 export type RecordingMode = z.infer<typeof RecordingModeSchema>;
 /**
- * First-class, authoritative per-camera storage mode — the netta choice the UI
- * reads directly (never inferred from `rules`):
+ * First-class, authoritative per-camera storage mode — the explicit choice the
+ * UI reads directly (never inferred from `rules`):
  *  - `off`        — not recording.
  *  - `events`     — record only around triggers (motion / audio threshold),
  *                   with pre/post-buffer.

package/dist/{sleep-CZDdRBua.mjs → sleep-Cc14_yxc.mjs}

@@ -250,6 +250,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["PipelineCameraUpdated"] = "pipeline.camera-updated";
 	/**
+	* The cluster camera-source OWNER changed (`clusterRoles.ingestNode`).
+	* Emitted by addon-pipeline-orchestrator whenever it (re)derives node
+	* capabilities — at boot, on agent online/offline, and on an ingest-node
+	* flip. Carries the resolved `ownerNodeId`. The stream-broker consumes it to
+	* keep its ingest-owner-gate decision current WITHOUT a per-`ensureBroker`
+	* cross-process `getIngestOwner` query (push the authority's decision instead
+	* of polling it on the hot path). Idempotent state — re-emitted on every
+	* topology change, so a dropped event self-heals on the next one (plus the
+	* broker's long backstop reconcile query).
+	*/
+	EventCategory["PipelineIngestOwnerChanged"] = "pipeline.ingest-owner-changed";
+	/**
 	* Periodic snapshot of per-node pipeline-runner load
 	* (`RunnerLocalLoad`). Emitted ~1Hz by every runner so UI dashboards
 	* subscribe instead of polling `pipelineRunner.getLocalLoad`.
@@ -3566,10 +3578,6 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
 			applyDeviceSettingsPatch: (input) => dispatchSystem("recording", "applyDeviceSettingsPatch", "mutation", input)
 		},
-		snapshotProvider: {
-			supportsDevice: (input) => dispatchSystem("snapshotProvider", "supportsDevice", "query", input),
-			getSnapshot: (input) => dispatchSystem("snapshotProvider", "getSnapshot", "query", input)
-		},
 		streamBroker: {
 			publishCameraStream: (input) => dispatchSystem("streamBroker", "publishCameraStream", "mutation", input),
 			retractCameraStream: (input) => dispatchSystem("streamBroker", "retractCameraStream", "mutation", input),

package/dist/{sleep-Dirr8nGw.js → sleep-DmP-uxoe.js}

@@ -250,6 +250,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["PipelineCameraUpdated"] = "pipeline.camera-updated";
 	/**
+	* The cluster camera-source OWNER changed (`clusterRoles.ingestNode`).
+	* Emitted by addon-pipeline-orchestrator whenever it (re)derives node
+	* capabilities — at boot, on agent online/offline, and on an ingest-node
+	* flip. Carries the resolved `ownerNodeId`. The stream-broker consumes it to
+	* keep its ingest-owner-gate decision current WITHOUT a per-`ensureBroker`
+	* cross-process `getIngestOwner` query (push the authority's decision instead
+	* of polling it on the hot path). Idempotent state — re-emitted on every
+	* topology change, so a dropped event self-heals on the next one (plus the
+	* broker's long backstop reconcile query).
+	*/
+	EventCategory["PipelineIngestOwnerChanged"] = "pipeline.ingest-owner-changed";
+	/**
 	* Periodic snapshot of per-node pipeline-runner load
 	* (`RunnerLocalLoad`). Emitted ~1Hz by every runner so UI dashboards
 	* subscribe instead of polling `pipelineRunner.getLocalLoad`.
@@ -3566,10 +3578,6 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
 			applyDeviceSettingsPatch: (input) => dispatchSystem("recording", "applyDeviceSettingsPatch", "mutation", input)
 		},
-		snapshotProvider: {
-			supportsDevice: (input) => dispatchSystem("snapshotProvider", "supportsDevice", "query", input),
-			getSnapshot: (input) => dispatchSystem("snapshotProvider", "getSnapshot", "query", input)
-		},
 		streamBroker: {
 			publishCameraStream: (input) => dispatchSystem("streamBroker", "publishCameraStream", "mutation", input),
 			retractCameraStream: (input) => dispatchSystem("streamBroker", "retractCameraStream", "mutation", input),

package/dist/types/agent-pipeline-settings.d.ts

@@ -23,10 +23,14 @@ import type { CameraPipelineConfig } from './camera-pipeline.js';
  * Every addon in the catalog gets one entry — whether enabled or not.
  * Operators edit these to pick models, tune settings, flip default
  * enabled state for their hardware.
+ *
+ * modelId present ONLY when the operator explicitly chose a model;
+ * absent = use this node's format default (resolved on-the-fly by the
+ * provider).
  */
 export interface AgentAddonConfig {
     readonly enabled: boolean;
-    readonly modelId: string;
+    readonly modelId?: string;
     readonly settings: Readonly<Record<string, unknown>>;
 }
 /**
@@ -48,9 +52,9 @@ export interface CameraStepOverridePatch {
  * ownership moved to per-addon global settings (detection-pipeline,
  * decoder-nodeav/ffmpeg, audio-analyzer). What's left on the
  * orchestrator is the per-step defaults map (modelId / step settings)
- * consumed by the resolver. The authoritative engine triple is read
- * from the `detection-pipeline` addon's global settings via
- * `readDetectionPipelineEngine()`.
+ * consumed by the resolver. Engine is node-local — each executing node
+ * resolves its own format default at dispatch time; it is never stored
+ * on these settings nor carried on the attach payload.
  */
 export interface AgentPipelineSettings {
     readonly addonDefaults: Readonly<Record<string, AgentAddonConfig>>;
@@ -81,6 +85,13 @@ export interface AgentPipelineSettings {
     readonly decode?: boolean;
     readonly audio?: boolean;
     readonly ingest?: boolean;
+    /**
+     * Operator override for the LAN host a cross-node decoder dials to reach
+     * THIS node's restream (Cluster UI). Absent → auto-detect: a remote runner
+     * falls back to its `CAMSTACK_HUB_URL`-derived host. Set only when the
+     * auto-detected address is wrong (multi-homed host, NAT, custom interface).
+     */
+    readonly reachableHost?: string;
 }
 /**
  * Per-camera pipeline settings. Sparse by design — a camera that has
@@ -108,12 +119,13 @@ export interface CameraPipelineSettings {
      * detection-pipeline addon's global settings. Operator picks steps
      * + audio model/enabled only. This keeps the override portable
      * across agent-moves and prevents a camera from being pinned to an
-     * engine the agent doesn't host.
+     * engine the agent doesn't host. `modelId` absent = data-only model
+     * selection — the executing node resolves its own format default.
      */
     readonly pipelineByAgent?: Readonly<Record<string, {
         readonly steps: CameraPipelineConfig['steps'];
         readonly audio: {
-            readonly modelId: string;
+            readonly modelId?: string;
             readonly enabled: boolean;
         } | null;
     }>>;

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

@@ -23,11 +23,25 @@ import type { PipelineEngineChoice } from './pipeline.js';
  * `audio-analyzer` not tied to this config.
  */
 export interface CameraPipelineConfig {
-    readonly engine: PipelineEngineChoice;
+    /**
+     * Benchmark/template engine HINT ONLY — an explicit engine override the
+     * Image-Tester carries when saving a template. It is NEVER a live-dispatch
+     * field: the attach payload (`RunnerCameraConfig`) no longer carries an
+     * engine, so this value cannot reach a node. Engine is node-local — the
+     * executing runner resolves its own format default at dispatch time.
+     */
+    readonly engine?: PipelineEngineChoice;
     readonly steps: readonly PipelineStepInputOutput[];
     readonly audio?: {
-        readonly engine: PipelineEngineChoice;
-        readonly modelId: string;
+        /** Benchmark/template engine hint only — see `engine` above. Not dispatched. */
+        readonly engine?: PipelineEngineChoice;
+        /**
+         * Present ONLY when the operator explicitly chose an audio model;
+         * absent = use this node's format default (resolved on-the-fly by
+         * the provider). Mirrors `AgentAddonConfig.modelId` (Task 4/5 of the
+         * engine-node-local refactor — model selection is data only).
+         */
+        readonly modelId?: string;
         readonly enabled: boolean;
         /**
          * Audio-classifier step settings (`enabledAudioClasses`,

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

@@ -0,0 +1,100 @@
+/**
+ * Variant grouping for the model selector.
+ *
+ * The catalog is a FLAT list of `ModelCatalogEntry` (ids like `yolo26s`,
+ * `yolo26s-int8`) — that stays the source of truth for resolution, download and
+ * persistence. This module is a PRESENTATION overlay: it folds the flat list
+ * into a `family → tier → variant` tree so the UI can offer one grouped picker
+ * ("YOLO26" → "Small" → "Int8") instead of a flat dropdown of every
+ * size×quantization combination, and maps a grouped selection back to a flat
+ * model id.
+ *
+ * Only entries carrying `group` and NOT flagged `legacy` participate; legacy /
+ * ungrouped / custom models are never surfaced in the grouped selector (they
+ * stay reachable via the flat id when explicitly pinned).
+ */
+import type { ModelFormat } from './models.js';
+export type VariantPrecision = 'fp32' | 'int8';
+export type VariantOptimization = 'standard' | 'fast';
+/**
+ * Minimal structural shape the grouped selector needs. Both the full
+ * `ModelCatalogEntry` (config UI) and the reduced `PipelineModelOption`
+ * (pipeline/device steppers) satisfy it, so one grouped picker serves every
+ * surface. `formats` is read only for "which formats ship" + a size hint, so a
+ * loose `{ sizeMB }`-per-key map covers both the catalog's rich format entries
+ * and the schema's `{ downloaded, sizeMB }` entries.
+ */
+export interface ModelVariantSource {
+    readonly id: string;
+    readonly name: string;
+    readonly legacy?: boolean;
+    readonly group?: {
+        readonly family: string;
+        readonly tier: string;
+        readonly precision?: VariantPrecision;
+        readonly optimization?: VariantOptimization;
+        readonly resolution?: number;
+    };
+    readonly formats: Readonly<Record<string, {
+        readonly sizeMB: number;
+    } | undefined>>;
+}
+/** One selectable variant of a tier (a single flat catalog entry). */
+export interface ModelVariantOption {
+    readonly modelId: string;
+    readonly precision: VariantPrecision;
+    readonly optimization: VariantOptimization;
+    /**
+     * Input resolution (square side, px). `undefined` ⇒ the family's native
+     * resolution (640 for yolo26). Reduced values (320 / 256) are the reduced-
+     * input latency variants.
+     */
+    readonly resolution?: number;
+    /** Short chip label: `Standard` | `Int8` | `Fast` | `Fast · Int8`. */
+    readonly label: string;
+    /** Formats this variant ships (drives per-node availability). */
+    readonly formats: readonly ModelFormat[];
+    /** Smallest declared build size (MB) — a rough size hint for the chip. */
+    readonly sizeMB: number;
+}
+/** One size tier within a family (e.g. YOLO26 "Small"), with its variants. */
+export interface ModelVariantTier {
+    readonly tier: string;
+    readonly label: string;
+    /** The fp32/standard base model id — the tier's canonical selection. */
+    readonly baseModelId: string;
+    readonly options: readonly ModelVariantOption[];
+}
+/** One model family (e.g. YOLO26), with its size tiers. */
+export interface ModelVariantFamily {
+    readonly family: string;
+    readonly label: string;
+    readonly tiers: readonly ModelVariantTier[];
+}
+/**
+ * Fold a flat catalog into the `family → tier → variant` tree. Deterministic
+ * ordering: tiers by the canonical size ladder (unknown tiers appended
+ * alphabetically), variants standard-before-int8 and fast last.
+ */
+export declare function buildModelVariantGroups(models: readonly ModelVariantSource[]): readonly ModelVariantFamily[];
+/**
+ * Map a grouped selection back to a flat catalog model id. Returns `null` when
+ * no entry matches (the UI then falls back to the tier base / format default).
+ * `precision`/`optimization` default to `fp32`/`standard` (the base build).
+ */
+export declare function resolveVariantModelId(models: readonly ModelVariantSource[], selection: {
+    readonly family: string;
+    readonly tier: string;
+    readonly precision?: VariantPrecision;
+    readonly optimization?: VariantOptimization;
+    /** `undefined` ⇒ the native-resolution build. */
+    readonly resolution?: number;
+}): string | null;
+/** Inverse: describe a flat model id as a grouped selection, or `null`. */
+export declare function describeModelVariant(models: readonly ModelVariantSource[], modelId: string): {
+    readonly family: string;
+    readonly tier: string;
+    readonly precision: VariantPrecision;
+    readonly optimization: VariantOptimization;
+    readonly resolution?: number;
+} | null;

package/dist/types/models.d.ts

@@ -94,6 +94,28 @@ export declare const ModelFormatsSchema: z.ZodObject<{
         }>>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * Variant-selector grouping axes. Shared by the full `ModelCatalogEntry` and by
+ * the reduced `PipelineModelOption` returned in `pipeline.getSchema()` so the
+ * grouped Family→Tier→Variant picker renders identically in the config UI and
+ * in the pipeline/device steppers. The flat `id` stays the source of truth for
+ * resolution/download/persistence; this is a presentation overlay resolved back
+ * to an `id`.
+ */
+export declare const ModelVariantGroupSchema: z.ZodObject<{
+    family: z.ZodString;
+    tier: z.ZodString;
+    precision: z.ZodOptional<z.ZodEnum<{
+        fp32: "fp32";
+        int8: "int8";
+    }>>;
+    optimization: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        fast: "fast";
+    }>>;
+    resolution: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelVariantGroup = z.infer<typeof ModelVariantGroupSchema>;
 export declare const ModelCatalogEntrySchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -180,6 +202,25 @@ export declare const ModelCatalogEntrySchema: z.ZodObject<{
         filename: z.ZodString;
         sizeMB: z.ZodNumber;
     }, z.core.$strip>>>>;
+    legacy: z.ZodOptional<z.ZodBoolean>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        map50: z.ZodOptional<z.ZodNumber>;
+        p95LatencyMs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+    license: z.ZodOptional<z.ZodString>;
+    group: z.ZodOptional<z.ZodObject<{
+        family: z.ZodString;
+        tier: z.ZodString;
+        precision: z.ZodOptional<z.ZodEnum<{
+            fp32: "fp32";
+            int8: "int8";
+        }>>;
+        optimization: z.ZodOptional<z.ZodEnum<{
+            standard: "standard";
+            fast: "fast";
+        }>>;
+        resolution: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ModelCatalogEntry = z.infer<typeof ModelCatalogEntrySchema>;
 export interface DetectionModel {
@@ -219,8 +260,8 @@ export interface CustomModelMetadata {
 export declare const ConvertTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     format: z.ZodLiteral<"openvino">;
     precisions: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-        fp16: "fp16";
         int8: "int8";
+        fp16: "fp16";
     }>>>;
 }, z.core.$strip>, z.ZodObject<{
     format: z.ZodLiteral<"coreml">;
@@ -273,8 +314,8 @@ export declare const ConvertArtifactSchema: z.ZodObject<{
         pt: "pt";
     }>;
     precision: z.ZodOptional<z.ZodEnum<{
-        fp16: "fp16";
         int8: "int8";
+        fp16: "fp16";
     }>>;
     sizeMB: z.ZodNumber;
     validated: z.ZodBoolean;
@@ -368,6 +409,25 @@ export declare const ConvertResultSchema: z.ZodObject<{
             filename: z.ZodString;
             sizeMB: z.ZodNumber;
         }, z.core.$strip>>>>;
+        legacy: z.ZodOptional<z.ZodBoolean>;
+        metrics: z.ZodOptional<z.ZodObject<{
+            map50: z.ZodOptional<z.ZodNumber>;
+            p95LatencyMs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strip>>;
+        license: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodObject<{
+            family: z.ZodString;
+            tier: z.ZodString;
+            precision: z.ZodOptional<z.ZodEnum<{
+                fp32: "fp32";
+                int8: "int8";
+            }>>;
+            optimization: z.ZodOptional<z.ZodEnum<{
+                standard: "standard";
+                fast: "fast";
+            }>>;
+            resolution: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         format: z.ZodEnum<{
@@ -378,8 +438,8 @@ export declare const ConvertResultSchema: z.ZodObject<{
             pt: "pt";
         }>;
         precision: z.ZodOptional<z.ZodEnum<{
-            fp16: "fp16";
             int8: "int8";
+            fp16: "fp16";
         }>>;
         sizeMB: z.ZodNumber;
         validated: z.ZodBoolean;

package/package.json

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

package/dist/capabilities/restreamer.cap.d.ts

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
-declare const RegisteredStreamSchema: z.ZodObject<{
-    streamId: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    codec: z.ZodString;
-    type: z.ZodEnum<{
-        audio: "audio";
-        video: "video";
-    }>;
-    sourceUrl: z.ZodString;
-}, z.core.$strip>;
-declare const ExposedResourceSchema: z.ZodObject<{
-    streamId: z.ZodString;
-    format: z.ZodString;
-    value: z.ZodString;
-}, z.core.$strip>;
-export declare const restreamerCapability: {
-    readonly name: "restreamer";
-    readonly scope: "system";
-    readonly mode: "collection";
-    readonly internal: true;
-    readonly methods: {
-        readonly registerDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                streamId: z.ZodString;
-                label: z.ZodOptional<z.ZodString>;
-                codec: z.ZodString;
-                type: z.ZodEnum<{
-                    audio: "audio";
-                    video: "video";
-                }>;
-                sourceUrl: z.ZodString;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        readonly unregisterDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        readonly getExposedResources: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            streamId: z.ZodString;
-            format: z.ZodString;
-            value: z.ZodString;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
-    };
-    /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
-    readonly mount: {
-        readonly kind: "skip";
-    };
-};
-export type IRestreamerProvider = InferProvider<typeof restreamerCapability>;
-export { RegisteredStreamSchema, ExposedResourceSchema };

package/dist/capabilities/snapshot-provider.cap.d.ts

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
-/**
- * snapshot-provider — collection of native snapshot implementations.
- *
- * Device provider addons (ONVIF, Frigate, etc.) register here
- * when they can capture frames through a protocol-native path (e.g.
- * ONVIF GetSnapshotUri, Frigate /api/<cam>/latest.jpg). The `snapshot`
- * singleton orchestrator iterates over the collection, asking each
- * provider whether it supports the requested device, and calls the
- * first matching one.
- *
- * If no provider in the collection supports a device, the orchestrator
- * falls back to `stream-broker.grabFrame` (universal fallback).
- *
- * Public tRPC router (auto-mounted) so out-of-process addons, agents,
- * and advanced clients can bypass the orchestrator when needed.
- */
-export declare const snapshotProviderCapability: {
-    readonly name: "snapshot-provider";
-    readonly scope: "system";
-    readonly mode: "collection";
-    readonly methods: {
-        readonly supportsDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly getSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            streamId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
-            base64: z.ZodString;
-            contentType: z.ZodString;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
-    };
-    /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
-    readonly mount: {
-        readonly kind: "custom";
-    };
-};
-export type ISnapshotProvider = InferProvider<typeof snapshotProviderCapability> & {
-    readonly id: string;
-    readonly name: string;
-};