@camstack/types 1.2.401 → 1.2.402

package/dist/capabilities/index.d.ts

@@ -211,7 +211,7 @@ export { type IOsdProvider, type OsdOverlay, type OsdOverlayKind, OsdOverlayKind
 export { type IOsdManagerProvider, type OsdNamedTemplate, OsdNamedTemplateSchema, type OsdRenderOutcome, OsdRenderOutcomeEnum, type OsdRenderResult, OsdRenderResultSchema, type OsdSlotBinding, OsdSlotBindingSchema, type OsdSlotView, OsdSlotViewSchema, type OsdSource, type OsdSourceOption, OsdSourceOptionSchema, OsdSourceSchema, type OsdSourceValueType, OsdSourceValueTypeEnum, type OsdTemplateBinding, OsdTemplateBindingSchema, type OsdTemplateFormat, OsdTemplateFormatSchema, type OsdTemplatePick, OsdTemplatePickSchema, type OsdTemplateTokenKind, OsdTemplateTokenKindSchema, osdManagerCapability, } from './osd-manager.cap.js';
 export { type IPetFeederProvider, PET_FEEDER_MANUAL_FEED_MAX, PET_FEEDER_MANUAL_FEED_MIN, type PetFeederStatus, PetFeederStatusSchema, petFeederCapability, } from './pet-feeder.cap.js';
 export { type IPlateGalleryProvider, type PlateInfo, plateGalleryCapability, type Vehicle, type VehicleSampleInfo, } from './plate-gallery.cap.js';
-export { type HardwareDecodeAccels, type HardwareEncoderId, type HardwareEncoderProbe, type HardwareEncoders, type IPlatformProbeProvider, platformProbeCapability, } from './platform-probe.cap.js';
+export { type AcceleratorRescan, type HardwareDecodeAccels, type HardwareEncoderId, type HardwareEncoderProbe, type HardwareEncoders, type IPlatformProbeProvider, platformProbeCapability, } from './platform-probe.cap.js';
 export { type IPowerMeterProvider, type PowerMeterStatus, PowerMeterStatusSchema, powerMeterCapability, } from './power-meter.cap.js';
 export { type GpsLocation, type IPresenceProvider, type PresenceStatus, PresenceStatusSchema, presenceCapability, } from './presence.cap.js';
 export { type IPressureSensorProvider, type PressureSensorStatus, PressureSensorStatusSchema, pressureSensorCapability, } from './pressure-sensor.cap.js';

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

@@ -608,6 +608,11 @@ declare const NodeInferenceDeviceSchema: z.ZodObject<{
         tflite: "tflite";
     }>;
     available: z.ZodBoolean;
+    presence: z.ZodOptional<z.ZodEnum<{
+        absent: "absent";
+        present: "present";
+        unknown: "unknown";
+    }>>;
     enabled: z.ZodBoolean;
     weight: z.ZodNumber;
     maxSessions: z.ZodNullable<z.ZodNumber>;
@@ -665,6 +670,11 @@ declare const NodeInferenceDevicesSchema: z.ZodObject<{
             tflite: "tflite";
         }>;
         available: z.ZodBoolean;
+        presence: z.ZodOptional<z.ZodEnum<{
+            absent: "absent";
+            present: "present";
+            unknown: "unknown";
+        }>>;
         enabled: z.ZodBoolean;
         weight: z.ZodNumber;
         maxSessions: z.ZodNullable<z.ZodNumber>;
@@ -1269,6 +1279,11 @@ export declare const pipelineOrchestratorCapability: {
                     tflite: "tflite";
                 }>;
                 available: z.ZodBoolean;
+                presence: z.ZodOptional<z.ZodEnum<{
+                    absent: "absent";
+                    present: "present";
+                    unknown: "unknown";
+                }>>;
                 enabled: z.ZodBoolean;
                 weight: z.ZodNumber;
                 maxSessions: z.ZodNullable<z.ZodNumber>;
@@ -1286,6 +1301,19 @@ export declare const pipelineOrchestratorCapability: {
                 }>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Delete ONE stored device entry of a node — the "forget" of a device the
+         * node no longer has (D919). Refused unless the node's probe ANSWERED and
+         * did not report the key: a present device is switched off, not forgotten,
+         * and an unreachable node proves nothing about its hardware. The rest of
+         * the node's map is kept as stored.
+         */
+        readonly forgetInferenceDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            agentNodeId: z.ZodString;
+            deviceKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
         /**
          * Reset one node's pipeline to its hardware-aware defaults — the HONEST
          * reset (replaces the executor's legacy `resetToDefault`, which cleared a

package/dist/capabilities/platform-probe.cap.d.ts

@@ -121,6 +121,43 @@ declare const HardwareDecodeAccelsSchema: z.ZodObject<{
     probedAt: z.ZodNumber;
 }, z.core.$strip>;
 export type HardwareDecodeAccels = z.infer<typeof HardwareDecodeAccelsSchema>;
+/**
+ * The answer of an accelerator rescan (D919): the node's device list after
+ * the re-probe, what changed, and the evidence that decided the Coral answer
+ * (`usbBus` — could the USB bus be read at all; `decidedBy` — USB ids, the PCI
+ * bus, the installed-delegate fallback, or nothing).
+ */
+declare const AcceleratorRescanSchema: z.ZodObject<{
+    devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        backend: z.ZodString;
+        device: z.ZodString;
+        format: z.ZodEnum<{
+            coreml: "coreml";
+            gguf: "gguf";
+            onnx: "onnx";
+            openvino: "openvino";
+            pt: "pt";
+            tflite: "tflite";
+        }>;
+        runtime: z.ZodLiteral<"python">;
+        score: z.ZodNumber;
+        available: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    appeared: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    disappeared: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    usbBus: z.ZodEnum<{
+        observed: "observed";
+        unobservable: "unobservable";
+    }>;
+    decidedBy: z.ZodEnum<{
+        "delegate-fallback": "delegate-fallback";
+        none: "none";
+        pci: "pci";
+        "usb-ids": "usb-ids";
+    }>;
+}, z.core.$strip>;
+export type AcceleratorRescan = z.infer<typeof AcceleratorRescanSchema>;
 export declare const platformProbeCapability: {
     readonly name: 'platform-probe';
     readonly scope: 'system';
@@ -336,6 +373,43 @@ export declare const platformProbeCapability: {
             preferred: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             rationale: z.ZodString;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Re-probe this node's accelerators NOW (Coral USB ids + PCIe apex units;
+         * `/sys` and `/dev` reads, no model load) and rebuild the device list that
+         * `getCapabilities` serves. The same re-probe runs every 60 s on its own;
+         * this is the operator's "rescan inference devices". Target a node with the
+         * `{ nodeId }` routing input, like `getCapabilities`.
+         */
+        readonly rescanAccelerators: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                backend: z.ZodString;
+                device: z.ZodString;
+                format: z.ZodEnum<{
+                    coreml: "coreml";
+                    gguf: "gguf";
+                    onnx: "onnx";
+                    openvino: "openvino";
+                    pt: "pt";
+                    tflite: "tflite";
+                }>;
+                runtime: z.ZodLiteral<"python">;
+                score: z.ZodNumber;
+                available: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            appeared: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            disappeared: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            usbBus: z.ZodEnum<{
+                observed: "observed";
+                unobservable: "unobservable";
+            }>;
+            decidedBy: z.ZodEnum<{
+                "delegate-fallback": "delegate-fallback";
+                none: "none";
+                pci: "pci";
+                "usb-ids": "usb-ids";
+            }>;
+        }, z.core.$strip>, "mutation">;
     };
 };
 export type IPlatformProbeProvider = InferProvider<typeof platformProbeCapability>;

package/dist/client.js

@@ -25317,6 +25317,13 @@ var TopologyNodeSchema = zod.z.object({
 	cpuModel: zod.z.string().nullable(),
 	cpuCores: zod.z.number(),
 	memoryMB: zod.z.number(),
+	/**
+	* The inference RUNTIMES installed on the node (`pythonRuntimes`: onnx,
+	* openvino, edgetpu …) — not its devices. An installed runtime says nothing
+	* about whether its hardware is there (a Coral delegate stays installed
+	* after the stick leaves, D919); the live device set is
+	* `pipelineOrchestrator.getNodeInferenceDevices`.
+	*/
 	engines: zod.z.array(zod.z.string()).readonly(),
 	isHub: zod.z.boolean(),
 	isOnline: zod.z.boolean(),
@@ -28169,6 +28176,7 @@ function createSystemProxy(api) {
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
+			forgetInferenceDevice: (input) => dispatch("pipelineOrchestrator", "forgetInferenceDevice", "mutation", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
 			planAutoTune: (input) => dispatch("pipelineOrchestrator", "planAutoTune", "query", input),
 			applyAutoTune: (input) => dispatch("pipelineOrchestrator", "applyAutoTune", "mutation", input),

package/dist/client.mjs

@@ -25316,6 +25316,13 @@ var TopologyNodeSchema = z.object({
 	cpuModel: z.string().nullable(),
 	cpuCores: z.number(),
 	memoryMB: z.number(),
+	/**
+	* The inference RUNTIMES installed on the node (`pythonRuntimes`: onnx,
+	* openvino, edgetpu …) — not its devices. An installed runtime says nothing
+	* about whether its hardware is there (a Coral delegate stays installed
+	* after the stick leaves, D919); the live device set is
+	* `pipelineOrchestrator.getNodeInferenceDevices`.
+	*/
 	engines: z.array(z.string()).readonly(),
 	isHub: z.boolean(),
 	isOnline: z.boolean(),
@@ -28168,6 +28175,7 @@ function createSystemProxy(api) {
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
+			forgetInferenceDevice: (input) => dispatch("pipelineOrchestrator", "forgetInferenceDevice", "mutation", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
 			planAutoTune: (input) => dispatch("pipelineOrchestrator", "planAutoTune", "query", input),
 			applyAutoTune: (input) => dispatch("pipelineOrchestrator", "applyAutoTune", "mutation", input),

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

@@ -7272,6 +7272,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineOrchestratorCapability.methods.getNodeInferenceDevices.output>;
             meta: object;
         }>;
+        forgetInferenceDevice: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineOrchestratorCapability.methods.forgetInferenceDevice.input>;
+            output: z.infer<typeof pipelineOrchestratorCapability.methods.forgetInferenceDevice.output>;
+            meta: object;
+        }>;
         resetNodePipelineDefaults: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
@@ -7777,6 +7784,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof platformProbeCapability.methods.resolveHwAccel.output>;
             meta: object;
         }>;
+        rescanAccelerators: TRPCMutationProcedure<{
+            input: {
+                nodeId?: string | undefined;
+            } | undefined;
+            output: z.infer<typeof platformProbeCapability.methods.rescanAccelerators.output>;
+            meta: object;
+        }>;
     }>>;
     powerMeter: TRPCBuiltRouter<{
         ctx: TrpcContext;

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: 1382 method paths across 179 capabilities.
+ * Coverage: 1384 method paths across 179 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

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

@@ -98,7 +98,7 @@ export interface SystemProxy {
     readonly oidcConnections: Pick<InferProvider<typeof oidcConnectionsCapability>, 'connectionFormSchema' | 'listConnections' | 'createConnection' | 'updateConnection' | 'deleteConnection'>;
     readonly osdManager: Pick<InferProvider<typeof osdManagerCapability>, 'getConditionSupport' | 'copyDeviceConfiguration' | 'listTemplates' | 'upsertTemplate' | 'deleteTemplate'>;
     readonly pipelineExecutor: Pick<InferProvider<typeof pipelineExecutorCapability>, 'getAvailableEngines' | 'getSelectedEngine' | 'getDefaultSteps' | 'getEngineProvisioning' | 'getVideoPipelineSteps' | 'setVideoPipelineSteps' | 'clearDeviceOverrides' | 'clearModelBoundDeviceOverrides' | 'getInferenceDeviceHealth' | 'rearmInferenceDevice' | 'getSchema' | 'getGlobalSteps' | 'getGlobalPipelineConfig' | 'getOrchestratorConfigSchema' | 'validatePipeline' | 'getCapabilities' | 'getAddonModels' | 'downloadModel' | 'deleteModel' | 'cacheFrameInPool' | 'inferCached' | 'uncacheFrame' | 'getEffectiveTuning' | 'listLoadedEngines' | 'spinEngine' | 'killEngine' | 'listReferenceImages' | 'getReferenceImage' | 'getReferenceAudioFiles' | 'getReferenceAudio' | 'getAudioCapabilities' | 'runAudioTest' | 'getDetectionConfigSchema'>;
-    readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'requestOccupancyLook' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getClusterModelChoice' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getIngestOwner' | 'getAudioNodeLoad' | 'getAudioAssignments' | 'getAgentSettings' | 'listAgentSettings' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentCapabilities' | 'setAgentDecodeLimits' | 'setAgentReachableHost' | 'setAgentInferenceDevices' | 'getNodeInferenceDevices' | 'resetNodePipelineDefaults' | 'planAutoTune' | 'applyAutoTune' | 'setLoadBalancingShares' | 'getPlacementStats' | 'suggestShares' | 'getEffectiveShares' | 'setShareSource' | 'getNodeBenchmarkPreflight' | 'startNodeBenchmark' | 'getNodeBenchmarkStatus' | 'abortNodeBenchmark' | 'getNodeBenchmarkCandidates' | 'listNodeBenchmarkResults' | 'deleteNodeBenchmarkResult' | 'getCameraStatuses' | 'setCameraSensors' | 'reconcileFromDisk' | 'getReconcileFromDiskStatus'>;
+    readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'requestOccupancyLook' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getClusterModelChoice' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getIngestOwner' | 'getAudioNodeLoad' | 'getAudioAssignments' | 'getAgentSettings' | 'listAgentSettings' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentCapabilities' | 'setAgentDecodeLimits' | 'setAgentReachableHost' | 'setAgentInferenceDevices' | 'getNodeInferenceDevices' | 'forgetInferenceDevice' | 'resetNodePipelineDefaults' | 'planAutoTune' | 'applyAutoTune' | 'setLoadBalancingShares' | 'getPlacementStats' | 'suggestShares' | 'getEffectiveShares' | 'setShareSource' | 'getNodeBenchmarkPreflight' | 'startNodeBenchmark' | 'getNodeBenchmarkStatus' | 'abortNodeBenchmark' | 'getNodeBenchmarkCandidates' | 'listNodeBenchmarkResults' | 'deleteNodeBenchmarkResult' | 'getCameraStatuses' | 'setCameraSensors' | 'reconcileFromDisk' | 'getReconcileFromDiskStatus'>;
     readonly pipelineRunner: Pick<InferProvider<typeof pipelineRunnerCapability>, 'attachCamera' | 'reportMotion' | 'getLocalLoad' | 'getLocalMetrics' | 'getAllCameraMetrics' | 'getLocalCameras' | 'getNativeCrop' | 'runStatelessStep' | 'startNodeBench' | 'getNodeBenchStatus' | 'abortNodeBench'>;
     readonly plateGallery: Pick<InferProvider<typeof plateGalleryCapability>, 'getPlateMedia' | 'searchPlates' | 'suggestPlateClusters' | 'correctPlateText' | 'deletePlate' | 'listVehicles' | 'createVehicle' | 'renameVehicle' | 'deleteVehicle' | 'listVehicleSamples' | 'removeVehicleSample' | 'assignPlate' | 'unassignPlate' | 'assignPlates' | 'unassignPlates'>;
     readonly recordEntries: Pick<InferProvider<typeof recordEntriesCapability>, 'listEntryKinds' | 'listEntries' | 'putEntry' | 'deleteEntry'>;

package/dist/index.js

@@ -54125,6 +54125,19 @@ var NodeInferenceDeviceSchema = zod.z.object({
 	/** Whether the node's live probe reports the device as usable right now. */
 	available: zod.z.boolean(),
 	/**
+	* Is the device on the node at all (D919)? `present` — the live probe
+	* reported it; `absent` — the probe ANSWERED and did not report it, so only
+	* its stored settings remain (unplugged, moved to another node): never
+	* eligible, whatever its stored `enabled`, and forgettable with
+	* `forgetInferenceDevice`; `unknown` — the probe did not answer, nothing is
+	* claimed (D315). Optional only for an orchestrator older than the field.
+	*/
+	presence: zod.z.enum([
+		"present",
+		"absent",
+		"unknown"
+	]).optional(),
+	/**
 	* Whether this device participates in dispatch. AUTO default (spec C2):
 	* accelerators are opt-OUT (a discovered NPU/iGPU/Coral/ANE with no stored
 	* entry is `true`); CPU is opt-IN (`false` by default — the fallback pool,
@@ -54562,6 +54575,20 @@ var pipelineOrchestratorCapability = {
 		*/
 		getNodeInferenceDevices: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), NodeInferenceDevicesSchema),
 		/**
+		* Delete ONE stored device entry of a node — the "forget" of a device the
+		* node no longer has (D919). Refused unless the node's probe ANSWERED and
+		* did not report the key: a present device is switched off, not forgotten,
+		* and an unreachable node proves nothing about its hardware. The rest of
+		* the node's map is kept as stored.
+		*/
+		forgetInferenceDevice: require_sleep.method(zod.z.object({
+			agentNodeId: zod.z.string(),
+			deviceKey: zod.z.string()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Reset one node's pipeline to its hardware-aware defaults — the HONEST
 		* reset (replaces the executor's legacy `resetToDefault`, which cleared a
 		* dead persisted step-tree seed nothing in the live path read):
@@ -65314,7 +65341,7 @@ var motionTriggerCapability = {
 		enabled: zod.z.boolean()
 	}), zod.z.void(), {
 		kind: "mutation",
-		auth: "admin"
+		auth: "protected"
 	}) },
 	events: { onMotionTriggerChanged: { data: zod.z.object({
 		deviceId: zod.z.number(),
@@ -66244,6 +66271,13 @@ var TopologyNodeSchema = zod.z.object({
 	cpuModel: zod.z.string().nullable(),
 	cpuCores: zod.z.number(),
 	memoryMB: zod.z.number(),
+	/**
+	* The inference RUNTIMES installed on the node (`pythonRuntimes`: onnx,
+	* openvino, edgetpu …) — not its devices. An installed runtime says nothing
+	* about whether its hardware is there (a Coral delegate stays installed
+	* after the stick leaves, D919); the live device set is
+	* `pipelineOrchestrator.getNodeInferenceDevices`.
+	*/
 	engines: zod.z.array(zod.z.string()).readonly(),
 	isHub: zod.z.boolean(),
 	isOnline: zod.z.boolean(),
@@ -67623,6 +67657,24 @@ var ResolvedInferenceConfigSchema = zod.z.object({
 	format: ModelFormatSchema,
 	reason: zod.z.string()
 });
+/**
+* The answer of an accelerator rescan (D919): the node's device list after
+* the re-probe, what changed, and the evidence that decided the Coral answer
+* (`usbBus` — could the USB bus be read at all; `decidedBy` — USB ids, the PCI
+* bus, the installed-delegate fallback, or nothing).
+*/
+var AcceleratorRescanSchema = zod.z.object({
+	devices: zod.z.array(InferenceDeviceDescriptorSchema).readonly(),
+	appeared: zod.z.array(zod.z.string()).readonly(),
+	disappeared: zod.z.array(zod.z.string()).readonly(),
+	usbBus: zod.z.enum(["observed", "unobservable"]),
+	decidedBy: zod.z.enum([
+		"usb-ids",
+		"pci",
+		"delegate-fallback",
+		"none"
+	])
+});
 var platformProbeCapability = {
 	name: "platform-probe",
 	scope: "system",
@@ -67631,7 +67683,18 @@ var platformProbeCapability = {
 		getCapabilities: require_sleep.method(zod.z.void(), PlatformCapabilitiesSchema),
 		getHardware: require_sleep.method(zod.z.void(), HardwareInfoSchema),
 		resolveInferenceConfig: require_sleep.method(zod.z.object({ requirements: zod.z.array(ModelRequirementSchema).readonly() }), ResolvedInferenceConfigSchema),
-		resolveHwAccel: require_sleep.method(zod.z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema)
+		resolveHwAccel: require_sleep.method(zod.z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema),
+		/**
+		* Re-probe this node's accelerators NOW (Coral USB ids + PCIe apex units;
+		* `/sys` and `/dev` reads, no model load) and rebuild the device list that
+		* `getCapabilities` serves. The same re-probe runs every 60 s on its own;
+		* this is the operator's "rescan inference devices". Target a node with the
+		* `{ nodeId }` routing input, like `getCapabilities`.
+		*/
+		rescanAccelerators: require_sleep.method(zod.z.void(), AcceleratorRescanSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -83577,6 +83640,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineOrchestrator.forgetInferenceDevice": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineOrchestrator.getAgentLoad": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -84153,6 +84222,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"platformProbe.rescanAccelerators": {
+		capName: "platform-probe",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"platformProbe.resolveHwAccel": {
 		capName: "platform-probe",
 		capScope: "system",
@@ -94502,6 +94577,7 @@ function createSystemProxy(api) {
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
+			forgetInferenceDevice: (input) => dispatch("pipelineOrchestrator", "forgetInferenceDevice", "mutation", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
 			planAutoTune: (input) => dispatch("pipelineOrchestrator", "planAutoTune", "query", input),
 			applyAutoTune: (input) => dispatch("pipelineOrchestrator", "applyAutoTune", "mutation", input),
@@ -101645,7 +101721,8 @@ function resolveEffectiveShares(input) {
 	const nodes = input.nodeIds.map((nodeId) => {
 		const eligibleKeys = new Set(input.eligibleDevices[nodeId] ?? []);
 		const named = weights.devices[nodeId] ?? {};
-		const keys = [...new Set([...Object.keys(named), ...eligibleKeys])].toSorted();
+		const absent = new Set(input.absentDevices?.[nodeId] ?? []);
+		const keys = [...new Set([...Object.keys(named), ...eligibleKeys])].filter((k) => !absent.has(k)).toSorted();
 		const perDevice = {};
 		for (const key of keys) perDevice[key] = positive(named[key]);
 		if (keys.length > 0) deviceWeights[nodeId] = perDevice;

package/dist/index.mjs

@@ -54124,6 +54124,19 @@ var NodeInferenceDeviceSchema = z.object({
 	/** Whether the node's live probe reports the device as usable right now. */
 	available: z.boolean(),
 	/**
+	* Is the device on the node at all (D919)? `present` — the live probe
+	* reported it; `absent` — the probe ANSWERED and did not report it, so only
+	* its stored settings remain (unplugged, moved to another node): never
+	* eligible, whatever its stored `enabled`, and forgettable with
+	* `forgetInferenceDevice`; `unknown` — the probe did not answer, nothing is
+	* claimed (D315). Optional only for an orchestrator older than the field.
+	*/
+	presence: z.enum([
+		"present",
+		"absent",
+		"unknown"
+	]).optional(),
+	/**
 	* Whether this device participates in dispatch. AUTO default (spec C2):
 	* accelerators are opt-OUT (a discovered NPU/iGPU/Coral/ANE with no stored
 	* entry is `true`); CPU is opt-IN (`false` by default — the fallback pool,
@@ -54561,6 +54574,20 @@ var pipelineOrchestratorCapability = {
 		*/
 		getNodeInferenceDevices: method(z.object({ nodeId: z.string() }), NodeInferenceDevicesSchema),
 		/**
+		* Delete ONE stored device entry of a node — the "forget" of a device the
+		* node no longer has (D919). Refused unless the node's probe ANSWERED and
+		* did not report the key: a present device is switched off, not forgotten,
+		* and an unreachable node proves nothing about its hardware. The rest of
+		* the node's map is kept as stored.
+		*/
+		forgetInferenceDevice: method(z.object({
+			agentNodeId: z.string(),
+			deviceKey: z.string()
+		}), z.object({ success: z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Reset one node's pipeline to its hardware-aware defaults — the HONEST
 		* reset (replaces the executor's legacy `resetToDefault`, which cleared a
 		* dead persisted step-tree seed nothing in the live path read):
@@ -65313,7 +65340,7 @@ var motionTriggerCapability = {
 		enabled: z.boolean()
 	}), z.void(), {
 		kind: "mutation",
-		auth: "admin"
+		auth: "protected"
 	}) },
 	events: { onMotionTriggerChanged: { data: z.object({
 		deviceId: z.number(),
@@ -66243,6 +66270,13 @@ var TopologyNodeSchema = z.object({
 	cpuModel: z.string().nullable(),
 	cpuCores: z.number(),
 	memoryMB: z.number(),
+	/**
+	* The inference RUNTIMES installed on the node (`pythonRuntimes`: onnx,
+	* openvino, edgetpu …) — not its devices. An installed runtime says nothing
+	* about whether its hardware is there (a Coral delegate stays installed
+	* after the stick leaves, D919); the live device set is
+	* `pipelineOrchestrator.getNodeInferenceDevices`.
+	*/
 	engines: z.array(z.string()).readonly(),
 	isHub: z.boolean(),
 	isOnline: z.boolean(),
@@ -67622,6 +67656,24 @@ var ResolvedInferenceConfigSchema = z.object({
 	format: ModelFormatSchema,
 	reason: z.string()
 });
+/**
+* The answer of an accelerator rescan (D919): the node's device list after
+* the re-probe, what changed, and the evidence that decided the Coral answer
+* (`usbBus` — could the USB bus be read at all; `decidedBy` — USB ids, the PCI
+* bus, the installed-delegate fallback, or nothing).
+*/
+var AcceleratorRescanSchema = z.object({
+	devices: z.array(InferenceDeviceDescriptorSchema).readonly(),
+	appeared: z.array(z.string()).readonly(),
+	disappeared: z.array(z.string()).readonly(),
+	usbBus: z.enum(["observed", "unobservable"]),
+	decidedBy: z.enum([
+		"usb-ids",
+		"pci",
+		"delegate-fallback",
+		"none"
+	])
+});
 var platformProbeCapability = {
 	name: "platform-probe",
 	scope: "system",
@@ -67630,7 +67682,18 @@ var platformProbeCapability = {
 		getCapabilities: method(z.void(), PlatformCapabilitiesSchema),
 		getHardware: method(z.void(), HardwareInfoSchema),
 		resolveInferenceConfig: method(z.object({ requirements: z.array(ModelRequirementSchema).readonly() }), ResolvedInferenceConfigSchema),
-		resolveHwAccel: method(z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema)
+		resolveHwAccel: method(z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema),
+		/**
+		* Re-probe this node's accelerators NOW (Coral USB ids + PCIe apex units;
+		* `/sys` and `/dev` reads, no model load) and rebuild the device list that
+		* `getCapabilities` serves. The same re-probe runs every 60 s on its own;
+		* this is the operator's "rescan inference devices". Target a node with the
+		* `{ nodeId }` routing input, like `getCapabilities`.
+		*/
+		rescanAccelerators: method(z.void(), AcceleratorRescanSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -83576,6 +83639,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineOrchestrator.forgetInferenceDevice": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineOrchestrator.getAgentLoad": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -84152,6 +84221,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"platformProbe.rescanAccelerators": {
+		capName: "platform-probe",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"platformProbe.resolveHwAccel": {
 		capName: "platform-probe",
 		capScope: "system",
@@ -94501,6 +94576,7 @@ function createSystemProxy(api) {
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
+			forgetInferenceDevice: (input) => dispatch("pipelineOrchestrator", "forgetInferenceDevice", "mutation", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
 			planAutoTune: (input) => dispatch("pipelineOrchestrator", "planAutoTune", "query", input),
 			applyAutoTune: (input) => dispatch("pipelineOrchestrator", "applyAutoTune", "mutation", input),
@@ -101644,7 +101720,8 @@ function resolveEffectiveShares(input) {
 	const nodes = input.nodeIds.map((nodeId) => {
 		const eligibleKeys = new Set(input.eligibleDevices[nodeId] ?? []);
 		const named = weights.devices[nodeId] ?? {};
-		const keys = [...new Set([...Object.keys(named), ...eligibleKeys])].toSorted();
+		const absent = new Set(input.absentDevices?.[nodeId] ?? []);
+		const keys = [...new Set([...Object.keys(named), ...eligibleKeys])].filter((k) => !absent.has(k)).toSorted();
 		const perDevice = {};
 		for (const key of keys) perDevice[key] = positive(named[key]);
 		if (keys.length > 0) deviceWeights[nodeId] = perDevice;

package/dist/pipeline/load-balancing/effective-shares.d.ts

@@ -26,6 +26,12 @@ export interface EffectiveSharesInput {
     readonly eligibleNodes: readonly string[];
     /** nodeId → device keys that can take sessions; a node absent here lists none. */
     readonly eligibleDevices: Readonly<Record<string, readonly string[]>>;
+    /**
+     * nodeId → device keys the node's probe answered WITHOUT (D919): stored
+     * weights survive a device that left, but it takes no share — neither set
+     * nor effective — and the election's weights never name it.
+     */
+    readonly absentDevices?: Readonly<Record<string, readonly string[]>>;
     readonly policy?: SessionPlacementPolicy;
     readonly computedAt?: number | null;
     readonly trigger?: string | null;

package/package.json

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