@camstack/types 1.1.24 → 1.1.26

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

@@ -51,7 +51,7 @@ export declare const decoderCapability: {
     readonly name: "decoder";
     readonly scope: "system";
     readonly mode: "singleton";
-    readonly preferredProvider: "decoder-ffmpeg";
+    readonly preferredProvider: "decoder-nodeav";
     readonly methods: {
         readonly supportsCodec: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             codec: z.ZodString;

package/dist/capabilities/pipeline-orchestrator.cap.d.ts

@@ -687,6 +687,11 @@ export declare const pipelineOrchestratorCapability: {
                 settings: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>>>;
             maxCameras: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            detectWeight: z.ZodOptional<z.ZodNumber>;
+            detect: z.ZodOptional<z.ZodBoolean>;
+            decode: z.ZodOptional<z.ZodBoolean>;
+            audio: z.ZodOptional<z.ZodBoolean>;
+            ingest: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Enumerate every agent's settings (hub + remote runners). */
         readonly listAgentSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
@@ -698,6 +703,11 @@ export declare const pipelineOrchestratorCapability: {
                     settings: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 }, z.core.$strip>>>;
                 maxCameras: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                detectWeight: z.ZodOptional<z.ZodNumber>;
+                detect: z.ZodOptional<z.ZodBoolean>;
+                decode: z.ZodOptional<z.ZodBoolean>;
+                audio: z.ZodOptional<z.ZodBoolean>;
+                ingest: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Bulk-replace ALL addon configs on one agent. Used by the agent-level PipelineEditor which emits the full map per edit. Merges on top of existing entries — omitted addonIds are left alone. */
@@ -745,6 +755,36 @@ export declare const pipelineOrchestratorCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Set a node's detection WEIGHT (relative share for the quota balancer).
+         * `null` clears it (back to the implicit weight 1). Unpinned cameras
+         * distribute proportionally to weight; `maxCameras` still clamps on top.
+         */
+        readonly setAgentDetectWeight: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            agentNodeId: z.ZodString;
+            detectWeight: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Set one node's placement CAPABILITIES — the per-node record that
+         * replaced the four flat orchestrator lists (`enabledNodes`,
+         * `enabledDecoderNodes`, `enabledAudioNodes`, `remoteSourcingNodes`).
+         * Each flag is optional in the patch: omit a flag to leave it unchanged,
+         * pass `null` to reset it to the node default (`hub` → capable, every
+         * other node → not). Detection/decode/audio eligibility is derived from
+         * these flags across the cluster; changing them re-derives the enabled
+         * sets and reconciles dispatch immediately.
+         */
+        readonly setAgentCapabilities: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            agentNodeId: z.ZodString;
+            detect: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            decode: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            audio: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            ingest: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
         /** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
         readonly getCameraSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;

package/dist/generated/addon-api.d.ts

@@ -9830,6 +9830,11 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                     settings: Readonly<Record<string, unknown>>;
                 }>>;
                 maxCameras: number | null;
+                detectWeight?: number | undefined;
+                detect?: boolean | undefined;
+                decode?: boolean | undefined;
+                audio?: boolean | undefined;
+                ingest?: boolean | undefined;
             } | null;
             meta: object;
         }>;
@@ -9846,6 +9851,11 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         settings: Readonly<Record<string, unknown>>;
                     }>>;
                     maxCameras: number | null;
+                    detectWeight?: number | undefined;
+                    detect?: boolean | undefined;
+                    decode?: boolean | undefined;
+                    audio?: boolean | undefined;
+                    ingest?: boolean | undefined;
                 };
             }[];
             meta: object;
@@ -9887,6 +9897,31 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             };
             meta: object;
         }>;
+        setAgentDetectWeight: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                agentNodeId: string;
+                detectWeight: number | null;
+            };
+            output: {
+                success: true;
+            };
+            meta: object;
+        }>;
+        setAgentCapabilities: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                agentNodeId: string;
+                detect?: boolean | null | undefined;
+                decode?: boolean | null | undefined;
+                audio?: boolean | null | undefined;
+                ingest?: boolean | null | undefined;
+            };
+            output: {
+                success: true;
+            };
+            meta: object;
+        }>;
         getCameraSettings: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -24168,6 +24203,11 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                     settings: Readonly<Record<string, unknown>>;
                 }>>;
                 maxCameras: number | null;
+                detectWeight?: number | undefined;
+                detect?: boolean | undefined;
+                decode?: boolean | undefined;
+                audio?: boolean | undefined;
+                ingest?: boolean | undefined;
             } | null;
             meta: object;
         }>;
@@ -24184,6 +24224,11 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         settings: Readonly<Record<string, unknown>>;
                     }>>;
                     maxCameras: number | null;
+                    detectWeight?: number | undefined;
+                    detect?: boolean | undefined;
+                    decode?: boolean | undefined;
+                    audio?: boolean | undefined;
+                    ingest?: boolean | undefined;
                 };
             }[];
             meta: object;
@@ -24225,6 +24270,31 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             };
             meta: object;
         }>;
+        setAgentDetectWeight: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                agentNodeId: string;
+                detectWeight: number | null;
+            };
+            output: {
+                success: true;
+            };
+            meta: object;
+        }>;
+        setAgentCapabilities: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                agentNodeId: string;
+                detect?: boolean | null | undefined;
+                decode?: boolean | null | undefined;
+                audio?: boolean | null | undefined;
+                ingest?: boolean | null | undefined;
+            };
+            output: {
+                success: true;
+            };
+            meta: object;
+        }>;
         getCameraSettings: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 733 method paths across 111 capabilities.
+ * Coverage: 735 method paths across 111 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/system-proxy.d.ts

@@ -72,7 +72,7 @@ export interface SystemProxy {
     readonly nodes: Pick<InferProvider<typeof nodesCapability>, 'topology' | 'deployAddon' | 'undeployAddon' | 'restartAddon' | 'restartProcess' | 'restartNode' | 'shutdownNode' | 'renameNode' | 'clusterAddonStatus' | 'getCapUsageGraph' | 'getNodeAddons' | 'setProcessLogLevel' | 'executeQuery'>;
     readonly notificationOutput: Pick<InferProvider<typeof notificationOutputCapability>, 'listTargetKinds' | 'listTargets' | 'discoverTargets' | 'send' | 'testTarget' | 'upsertTarget' | 'deleteTarget' | 'setTargetEnabled'>;
     readonly pipelineExecutor: Pick<InferProvider<typeof pipelineExecutorCapability>, 'getAvailableEngines' | 'getSelectedEngine' | 'getDefaultSteps' | 'reprobeEngine' | 'getEngineProvisioning' | 'getVideoPipelineSteps' | 'setVideoPipelineSteps' | 'getSchema' | 'getGlobalSteps' | 'getGlobalPipelineConfig' | 'getOrchestratorConfigSchema' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate' | 'getCapabilities' | 'getAddonModels' | 'downloadModel' | 'deleteModel' | 'detect' | 'cacheFrameInPool' | 'inferCached' | 'uncacheFrame' | 'getEffectiveTuning' | 'listLoadedEngines' | 'spinEngine' | 'killEngine' | 'listReferenceImages' | 'getReferenceImage' | 'getReferenceAudioFiles' | 'getReferenceAudio' | 'getAudioCapabilities' | 'runAudioTest' | 'getDetectionConfigSchema'>;
-    readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getDecoderAssignments' | 'getAudioNodeLoad' | 'getAgentSettings' | 'listAgentSettings' | 'setAgentAddonDefaults' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'getCameraStatuses' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate'>;
+    readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getDecoderAssignments' | 'getAudioNodeLoad' | 'getAgentSettings' | 'listAgentSettings' | 'setAgentAddonDefaults' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentDetectWeight' | 'setAgentCapabilities' | 'getCameraStatuses' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate'>;
     readonly pipelineRunner: Pick<InferProvider<typeof pipelineRunnerCapability>, 'attachCamera' | 'reportMotion' | 'getLocalLoad' | 'getLocalMetrics' | 'getAllCameraMetrics' | 'getLocalCameras'>;
     readonly plateGallery: Pick<InferProvider<typeof plateGalleryCapability>, 'getPlateMedia' | 'searchPlates' | 'suggestPlateClusters' | 'correctPlateText' | 'deletePlate'>;
     readonly recording: Pick<InferProvider<typeof recordingCapability>, 'getStorageUsage'>;

package/dist/index.js

@@ -11998,6 +11998,8 @@ function createSystemProxy(api) {
 			setAgentAddonDefaults: (input) => dispatch("pipelineOrchestrator", "setAgentAddonDefaults", "mutation", input),
 			removeAgentSettings: (input) => dispatch("pipelineOrchestrator", "removeAgentSettings", "mutation", input),
 			setAgentMaxCameras: (input) => dispatch("pipelineOrchestrator", "setAgentMaxCameras", "mutation", input),
+			setAgentDetectWeight: (input) => dispatch("pipelineOrchestrator", "setAgentDetectWeight", "mutation", input),
+			setAgentCapabilities: (input) => dispatch("pipelineOrchestrator", "setAgentCapabilities", "mutation", input),
 			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			listTemplates: (input) => dispatch("pipelineOrchestrator", "listTemplates", "query", input),
 			saveTemplate: (input) => dispatch("pipelineOrchestrator", "saveTemplate", "mutation", input),
@@ -14255,7 +14257,7 @@ var decoderCapability = {
 	name: "decoder",
 	scope: "system",
 	mode: "singleton",
-	preferredProvider: "decoder-ffmpeg",
+	preferredProvider: "decoder-nodeav",
 	methods: {
 		supportsCodec: require_sleep.method(zod.z.object({ codec: zod.z.string() }), zod.z.boolean()),
 		getInfo: require_sleep.method(zod.z.void(), zod.z.object({
@@ -16920,7 +16922,17 @@ var AgentAddonConfigSchema = zod.z.object({
 });
 var AgentPipelineSettingsSchema = zod.z.object({
 	addonDefaults: zod.z.record(zod.z.string(), AgentAddonConfigSchema).readonly(),
-	maxCameras: zod.z.number().int().nonnegative().nullable().default(null)
+	maxCameras: zod.z.number().int().nonnegative().nullable().default(null),
+	/** Per-node detection weight (relative share for the quota balancer). */
+	detectWeight: zod.z.number().positive().optional(),
+	/** Node is eligible to run the detection pipeline (decode + inference). */
+	detect: zod.z.boolean().optional(),
+	/** Node is eligible to host decoder sessions. */
+	decode: zod.z.boolean().optional(),
+	/** Node is eligible to run audio-analyzer sessions. */
+	audio: zod.z.boolean().optional(),
+	/** Node is eligible to be the ingest / source-owner (serve the restream). */
+	ingest: zod.z.boolean().optional()
 });
 var CameraPipelineForAgentSchema = zod.z.object({
 	steps: zod.z.array(PipelineStepInputSchema).readonly(),
@@ -17362,6 +17374,38 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Set a node's detection WEIGHT (relative share for the quota balancer).
+		* `null` clears it (back to the implicit weight 1). Unpinned cameras
+		* distribute proportionally to weight; `maxCameras` still clamps on top.
+		*/
+		setAgentDetectWeight: require_sleep.method(zod.z.object({
+			agentNodeId: zod.z.string(),
+			detectWeight: zod.z.number().positive().nullable()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Set one node's placement CAPABILITIES — the per-node record that
+		* replaced the four flat orchestrator lists (`enabledNodes`,
+		* `enabledDecoderNodes`, `enabledAudioNodes`, `remoteSourcingNodes`).
+		* Each flag is optional in the patch: omit a flag to leave it unchanged,
+		* pass `null` to reset it to the node default (`hub` → capable, every
+		* other node → not). Detection/decode/audio eligibility is derived from
+		* these flags across the cluster; changing them re-derives the enabled
+		* sets and reconciles dispatch immediately.
+		*/
+		setAgentCapabilities: require_sleep.method(zod.z.object({
+			agentNodeId: zod.z.string(),
+			detect: zod.z.boolean().nullable().optional(),
+			decode: zod.z.boolean().nullable().optional(),
+			audio: zod.z.boolean().nullable().optional(),
+			ingest: zod.z.boolean().nullable().optional()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: require_sleep.method(zod.z.object({ deviceId: zod.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. */
@@ -25789,6 +25833,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setAgentCapabilities": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineOrchestrator.setAgentDetectWeight": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setAgentMaxCameras": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",

package/dist/index.mjs

@@ -11997,6 +11997,8 @@ function createSystemProxy(api) {
 			setAgentAddonDefaults: (input) => dispatch("pipelineOrchestrator", "setAgentAddonDefaults", "mutation", input),
 			removeAgentSettings: (input) => dispatch("pipelineOrchestrator", "removeAgentSettings", "mutation", input),
 			setAgentMaxCameras: (input) => dispatch("pipelineOrchestrator", "setAgentMaxCameras", "mutation", input),
+			setAgentDetectWeight: (input) => dispatch("pipelineOrchestrator", "setAgentDetectWeight", "mutation", input),
+			setAgentCapabilities: (input) => dispatch("pipelineOrchestrator", "setAgentCapabilities", "mutation", input),
 			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			listTemplates: (input) => dispatch("pipelineOrchestrator", "listTemplates", "query", input),
 			saveTemplate: (input) => dispatch("pipelineOrchestrator", "saveTemplate", "mutation", input),
@@ -14254,7 +14256,7 @@ var decoderCapability = {
 	name: "decoder",
 	scope: "system",
 	mode: "singleton",
-	preferredProvider: "decoder-ffmpeg",
+	preferredProvider: "decoder-nodeav",
 	methods: {
 		supportsCodec: method(z.object({ codec: z.string() }), z.boolean()),
 		getInfo: method(z.void(), z.object({
@@ -16919,7 +16921,17 @@ var AgentAddonConfigSchema = z.object({
 });
 var AgentPipelineSettingsSchema = z.object({
 	addonDefaults: z.record(z.string(), AgentAddonConfigSchema).readonly(),
-	maxCameras: z.number().int().nonnegative().nullable().default(null)
+	maxCameras: z.number().int().nonnegative().nullable().default(null),
+	/** Per-node detection weight (relative share for the quota balancer). */
+	detectWeight: z.number().positive().optional(),
+	/** Node is eligible to run the detection pipeline (decode + inference). */
+	detect: z.boolean().optional(),
+	/** Node is eligible to host decoder sessions. */
+	decode: z.boolean().optional(),
+	/** Node is eligible to run audio-analyzer sessions. */
+	audio: z.boolean().optional(),
+	/** Node is eligible to be the ingest / source-owner (serve the restream). */
+	ingest: z.boolean().optional()
 });
 var CameraPipelineForAgentSchema = z.object({
 	steps: z.array(PipelineStepInputSchema).readonly(),
@@ -17361,6 +17373,38 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Set a node's detection WEIGHT (relative share for the quota balancer).
+		* `null` clears it (back to the implicit weight 1). Unpinned cameras
+		* distribute proportionally to weight; `maxCameras` still clamps on top.
+		*/
+		setAgentDetectWeight: method(z.object({
+			agentNodeId: z.string(),
+			detectWeight: z.number().positive().nullable()
+		}), z.object({ success: z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Set one node's placement CAPABILITIES — the per-node record that
+		* replaced the four flat orchestrator lists (`enabledNodes`,
+		* `enabledDecoderNodes`, `enabledAudioNodes`, `remoteSourcingNodes`).
+		* Each flag is optional in the patch: omit a flag to leave it unchanged,
+		* pass `null` to reset it to the node default (`hub` → capable, every
+		* other node → not). Detection/decode/audio eligibility is derived from
+		* these flags across the cluster; changing them re-derives the enabled
+		* sets and reconciles dispatch immediately.
+		*/
+		setAgentCapabilities: method(z.object({
+			agentNodeId: z.string(),
+			detect: z.boolean().nullable().optional(),
+			decode: z.boolean().nullable().optional(),
+			audio: z.boolean().nullable().optional(),
+			ingest: z.boolean().nullable().optional()
+		}), z.object({ success: z.literal(true) }), {
+			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. */
@@ -25788,6 +25832,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setAgentCapabilities": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineOrchestrator.setAgentDetectWeight": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setAgentMaxCameras": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",

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

@@ -61,6 +61,26 @@ export interface AgentPipelineSettings {
      * without migration.
      */
     readonly maxCameras?: number | null;
+    /**
+     * Optional per-node detection WEIGHT (relative share). Unpinned cameras
+     * distribute proportionally to weight across detect-capable nodes (e.g.
+     * Mac 60 / hub 30 / N100 10). `undefined`/absent = weight 1 (equal share,
+     * back-compat: identical to score-only balancing). Ceiling (`maxCameras`)
+     * still clamps on top of the weight share.
+     */
+    readonly detectWeight?: number;
+    /**
+     * Placement capabilities (placement-model-design §6) — the per-node record
+     * that replaced the four flat orchestrator lists (`enabledNodes`,
+     * `enabledDecoderNodes`, `enabledAudioNodes`, `remoteSourcingNodes`). Each
+     * flag is optional; an absent flag inherits the node default (`hub` →
+     * capable, every other node → not). The orchestrator derives its
+     * enabled-node sets from these flags across the cluster.
+     */
+    readonly detect?: boolean;
+    readonly decode?: boolean;
+    readonly audio?: boolean;
+    readonly ingest?: boolean;
 }
 /**
  * Per-camera pipeline settings. Sparse by design — a camera that has

package/package.json

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