@camstack/types 1.1.33 → 1.1.35

package/dist/addon.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DmP-uxoe.js");
+const require_sleep = require("./sleep-DuN1nc6O.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 exports.BaseAddon = require_sleep.BaseAddon;
 exports.DATAPLANE_SECRET_HEADER = require_sleep.DATAPLANE_SECRET_HEADER;

package/dist/addon.mjs

@@ -1,3 +1,3 @@
-import { A as ReadinessRegistry, C as asJsonObject, O as parseJsonUnknown, P as scopeKey, T as asString, a as adminUiCapability, b as DeviceType, gt as DisposerChain, ht as EventCategory, i as deviceOpsCapability, j as ReadinessTimeoutError, k as DATAPLANE_SECRET_HEADER, o as createDeviceProxy, ot as BaseAddon, p as expandCapMethods, st as normalizeAddonInitResult, t as sleep, ut as emitReadiness } from "./sleep-Cc14_yxc.mjs";
+import { A as ReadinessRegistry, C as asJsonObject, O as parseJsonUnknown, P as scopeKey, T as asString, a as adminUiCapability, b as DeviceType, gt as DisposerChain, ht as EventCategory, i as deviceOpsCapability, j as ReadinessTimeoutError, k as DATAPLANE_SECRET_HEADER, o as createDeviceProxy, ot as BaseAddon, p as expandCapMethods, st as normalizeAddonInitResult, t as sleep, ut as emitReadiness } from "./sleep-DiQ8xW1M.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 export { BaseAddon, DATAPLANE_SECRET_HEADER, DeviceType, DisposerChain, EventCategory, ReadinessRegistry, ReadinessTimeoutError, adminUiCapability, asJsonObject, asString, createDeviceProxy, deviceOpsCapability, emitReadiness, errMsg, expandCapMethods, normalizeAddonInitResult, parseJsonUnknown, scopeKey, sleep };

package/dist/capabilities/addon-pages-source.cap.d.ts

@@ -19,6 +19,8 @@ declare const AddonPageDeclarationSchema: z.ZodObject<{
     path: z.ZodString;
     remoteName: z.ZodString;
     bundle: z.ZodString;
+    section: z.ZodOptional<z.ZodString>;
+    sectionLabel: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const addonPagesSourceCapability: {
     readonly name: "addon-pages-source";
@@ -33,6 +35,8 @@ export declare const addonPagesSourceCapability: {
             path: z.ZodString;
             remoteName: z.ZodString;
             bundle: z.ZodString;
+            section: z.ZodOptional<z.ZodString>;
+            sectionLabel: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
     };
 };

package/dist/capabilities/addon-pages.cap.d.ts

@@ -9,6 +9,8 @@ declare const AddonPageInfoSchema: z.ZodObject<{
         path: z.ZodString;
         remoteName: z.ZodString;
         bundle: z.ZodString;
+        section: z.ZodOptional<z.ZodString>;
+        sectionLabel: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     bundleUrl: z.ZodString;
 }, z.core.$strip>;
@@ -26,6 +28,8 @@ export declare const addonPagesCapability: {
                 path: z.ZodString;
                 remoteName: z.ZodString;
                 bundle: z.ZodString;
+                section: z.ZodOptional<z.ZodString>;
+                sectionLabel: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
             bundleUrl: z.ZodString;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;

package/dist/capabilities/custom-model-registry.cap.d.ts

@@ -122,6 +122,7 @@ export declare const CustomModelDescriptorSchema: z.ZodObject<{
                 standard: "standard";
                 fast: "fast";
             }>>;
+            resolution: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -237,6 +238,7 @@ export declare const customModelRegistryCapability: {
                         standard: "standard";
                         fast: "fast";
                     }>>;
+                    resolution: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;

package/dist/capabilities/index.d.ts

@@ -72,9 +72,9 @@ export { type Attachment, AttachmentMediaTypeSchema, type AttachmentMediaType, A
 export { type IOauthIntegrationProvider, type OauthIntegrationDescriptor, OauthIntegrationDescriptorSchema, oauthIntegrationCapability, } from './oauth-integration.cap.js';
 export { type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, EventKindSchema, type IPipelineAnalyticsProvider, type MediaFile, type MediaFileKind, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type ScoredObjectEvent, ScoredObjectEventSchema, type Track, TrackedDetectionSchema, TrackSchema, type TrackState, TrackStateSchema, } from './pipeline-analytics.cap.js';
 export type { PipelineStepInputOutput, PipelineValidationIssue, PipelineValidationResult, } from './pipeline-executor.cap.js';
-export { DetectorOutputSchema, ModelSubstitutionSchema, PipelineDefaultStepSchema, PipelineEngineChoiceSchema, PipelineRunResultBridge, PipelineStepInputSchema, PipelineValidationIssueSchema, PipelineValidationResultSchema, pipelineExecutorCapability, } from './pipeline-executor.cap.js';
+export { ModelSubstitutionSchema, PipelineDefaultStepSchema, PipelineEngineChoiceSchema, PipelineRunResultBridge, PipelineStepInputSchema, PipelineValidationIssueSchema, PipelineValidationResultSchema, pipelineExecutorCapability, } from './pipeline-executor.cap.js';
 export type { CameraAssignmentStatus, CameraAudioStatus, CameraBrokerProfile, CameraBrokerStatus, CameraDecoderShm, CameraDecoderStatus, CameraDetectionPhase, CameraDetectionProvisioning, CameraDetectionProvisioningState, CameraDetectionStatus, CameraMotionStatus, CameraRecordingMode, CameraRecordingStatus, CameraSourceStatus, CameraSourceStream, CameraStatus, IngestOwner, } from './pipeline-orchestrator.cap.js';
-export { AgentLoadSummarySchema, CameraAssignmentStatusSchema, CameraAudioStatusSchema, CameraBrokerProfileSchema, CameraBrokerStatusSchema, CameraDecoderShmSchema, CameraDecoderStatusSchema, CameraDetectionPhaseSchema, CameraDetectionProvisioningSchema, CameraDetectionProvisioningStateSchema, CameraDetectionStatusSchema, CameraMotionStatusSchema, CameraRecordingModeSchema, CameraRecordingStatusSchema, CameraSourceStatusSchema, CameraSourceStreamSchema, CameraStatusSchema, CapabilityBindingsSchema, DecoderAssignmentSchema, GlobalMetricsSchema, IngestOwnerSchema, PipelineAssignmentSchema, pipelineOrchestratorCapability, } from './pipeline-orchestrator.cap.js';
+export { AgentLoadSummarySchema, CameraAssignmentStatusSchema, CameraAudioStatusSchema, CameraBrokerProfileSchema, CameraBrokerStatusSchema, CameraDecoderShmSchema, CameraDecoderStatusSchema, CameraDetectionPhaseSchema, CameraDetectionProvisioningSchema, CameraDetectionProvisioningStateSchema, CameraDetectionStatusSchema, CameraMotionStatusSchema, CameraRecordingModeSchema, CameraRecordingStatusSchema, CameraSourceStatusSchema, CameraSourceStreamSchema, CameraStatusSchema, CapabilityBindingsSchema, GlobalMetricsSchema, IngestOwnerSchema, PipelineAssignmentSchema, pipelineOrchestratorCapability, } from './pipeline-orchestrator.cap.js';
 export type { MotionSource, MotionSources, ReportMotionInput, RunnerFrameSource, } from './pipeline-runner.cap.js';
 export { MotionSourceEnum, MotionSourcesSchema, pipelineRunnerCapability, ReportMotionInputSchema, RunnerCameraConfigSchema, RunnerCameraDeviceUIFields, RunnerFrameSourceSchema, RunnerLocalLoadSchema, RunnerLocalMetricsSchema, } from './pipeline-runner.cap.js';
 export { AudioChunkInputSchema, AudioClassificationLabelSchema, AudioLevelSchema, BoundingBoxSchema, FrameInputSchema, SpatialDetectionSchema, } from './schemas/detection-shared.js';

package/dist/capabilities/model-convert.cap.d.ts

@@ -212,6 +212,7 @@ export declare const modelConvertCapability: {
                         standard: "standard";
                         fast: "fast";
                     }>>;
+                    resolution: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
             artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{

package/dist/capabilities/model-distributor.cap.d.ts

@@ -123,6 +123,7 @@ export declare const ModelDistributeInputSchema: z.ZodObject<{
                 standard: "standard";
                 fast: "fast";
             }>>;
+            resolution: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -251,6 +252,7 @@ export declare const modelDistributorCapability: {
                         standard: "standard";
                         fast: "fast";
                     }>>;
+                    resolution: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{

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

@@ -108,6 +108,7 @@ declare const PipelineModelOptionSchema: z.ZodObject<{
             standard: "standard";
             fast: "fast";
         }>>;
+        resolution: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     legacy: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
@@ -148,6 +149,7 @@ declare const PipelineAddonSchemaSchema: z.ZodObject<{
                 standard: "standard";
                 fast: "fast";
             }>>;
+            resolution: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         legacy: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
@@ -212,6 +214,7 @@ declare const PipelineSlotSchemaSchema: z.ZodObject<{
                     standard: "standard";
                     fast: "fast";
                 }>>;
+                resolution: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
             legacy: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
@@ -316,6 +319,7 @@ declare const PipelineSchemaSchema: z.ZodObject<{
                         standard: "standard";
                         fast: "fast";
                     }>>;
+                    resolution: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strip>>;
                 legacy: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>>;
@@ -328,21 +332,6 @@ declare const PipelineSchemaSchema: z.ZodObject<{
         }, z.core.$strip>>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
-declare const DetectorOutputSchema: z.ZodObject<{
-    detections: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        class: z.ZodString;
-        originalClass: z.ZodString;
-        score: z.ZodNumber;
-        bbox: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            w: z.ZodNumber;
-            h: z.ZodNumber;
-        }, z.core.$strip>;
-    }, z.core.$strip>>>;
-    inferenceMs: z.ZodNumber;
-    modelId: z.ZodString;
-}, z.core.$strip>;
 declare const EngineProvisioningSchema: z.ZodObject<{
     runtimeId: z.ZodNullable<z.ZodEnum<{
         onnx: "onnx";
@@ -534,6 +523,27 @@ export declare const pipelineExecutorCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Clear THIS node's executor-side PER-DEVICE settings stores (the
+         * per-camera step overrides the object-detection root reads via
+         * `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
+         * generated cap-router strips it (default `nodeIdMode: 'routing'`) and
+         * dispatches to that node, so the provider method runs ON the target
+         * node and receives no `nodeId`.
+         *
+         * This is the slimmed executor leg of the orchestrator's
+         * `resetNodePipelineDefaults` flow (which owns the real reset: node
+         * addonDefaults pins + per-camera orchestrator overrides). The legacy
+         * `resetToDefault` — which reset a persisted global step-tree seed
+         * nothing in the live per-camera path read — was removed together with
+         * that seed.
+         */
+        readonly clearDeviceOverrides: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+            clearedDevices: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
         readonly getSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             availableEngines: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 engine: z.ZodObject<{
@@ -627,6 +637,7 @@ export declare const pipelineExecutorCapability: {
                                 standard: "standard";
                                 fast: "fast";
                             }>>;
+                            resolution: z.ZodOptional<z.ZodNumber>;
                         }, z.core.$strip>>;
                         legacy: z.ZodOptional<z.ZodBoolean>;
                     }, z.core.$strip>>>;
@@ -797,37 +808,6 @@ export declare const pipelineExecutorCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
-        readonly detect: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-            frame: z.ZodObject<{
-                data: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
-                format: z.ZodEnum<{
-                    jpeg: "jpeg";
-                    rgb: "rgb";
-                    bgr: "bgr";
-                    yuv420: "yuv420";
-                    gray: "gray";
-                }>;
-                width: z.ZodNumber;
-                height: z.ZodNumber;
-                timestamp: z.ZodNumber;
-            }, z.core.$strip>;
-            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>, z.ZodObject<{
-            detections: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                class: z.ZodString;
-                originalClass: z.ZodString;
-                score: z.ZodNumber;
-                bbox: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                    w: z.ZodNumber;
-                    h: z.ZodNumber;
-                }, z.core.$strip>;
-            }, z.core.$strip>>>;
-            inferenceMs: z.ZodNumber;
-            modelId: z.ZodString;
-        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * Stateless single-frame execution. Callers (runner, benchmark) pass
          * the complete `engine` + `steps` tree; the executor holds no state
@@ -1119,4 +1099,4 @@ export declare const pipelineExecutorCapability: {
     };
 };
 export type IPipelineExecutorProvider = InferProvider<typeof pipelineExecutorCapability>;
-export { PipelineEngineChoiceSchema, PipelineDefaultStepSchema, DetectorOutputSchema, PipelineSchemaSchema, PipelineAddonSchemaSchema, PipelineSlotSchemaSchema, PipelineModelOptionSchema, AvailableEngineSchema, PipelineTemplateSchema, PipelineTemplateStepSchema, EngineDeviceInfoSchema, EngineProvisioningSchema, ModelSubstitutionSchema, PipelineValidationIssueSchema, PipelineValidationResultSchema, };
+export { PipelineEngineChoiceSchema, PipelineDefaultStepSchema, PipelineSchemaSchema, PipelineAddonSchemaSchema, PipelineSlotSchemaSchema, PipelineModelOptionSchema, AvailableEngineSchema, PipelineTemplateSchema, PipelineTemplateStepSchema, EngineDeviceInfoSchema, EngineProvisioningSchema, ModelSubstitutionSchema, PipelineValidationIssueSchema, PipelineValidationResultSchema, };

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

@@ -111,22 +111,6 @@ declare const PipelineAssignmentSchema: z.ZodObject<{
     }>;
     assignedAt: z.ZodNumber;
 }, z.core.$strip>;
-/**
- * Decoder placement record. Symmetric to `PipelineAssignmentSchema` but for
- * the decoder-node placement domain (`balanceDecoder` decision: manual pin
- * → co-located with pipeline → capacity).
- */
-declare const DecoderAssignmentSchema: z.ZodObject<{
-    deviceId: z.ZodNumber;
-    decoderNodeId: z.ZodString;
-    pinned: z.ZodBoolean;
-    reason: z.ZodEnum<{
-        manual: "manual";
-        capacity: "capacity";
-        "hardware-affinity": "hardware-affinity";
-        "co-located": "co-located";
-    }>;
-}, z.core.$strip>;
 /**
  * Per-agent load summary surfaced to the load balancer + dashboards.
  * Aggregated from each runner's `getLocalLoad` cap call.
@@ -619,27 +603,6 @@ export declare const pipelineOrchestratorCapability: {
             reachableHost: z.ZodOptional<z.ZodString>;
             configIssue: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
-        /** Pin a device's decoder to a specific node. */
-        readonly assignDecoder: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            nodeId: z.ZodString;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        /** Clear a device's decoder pin (revert to auto). */
-        readonly unassignDecoder: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-        }, z.core.$strip>, z.ZodVoid, "mutation">;
-        /** Get every camera's decoder placement. */
-        readonly getDecoderAssignments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            decoderNodeId: z.ZodString;
-            pinned: z.ZodBoolean;
-            reason: z.ZodEnum<{
-                manual: "manual";
-                capacity: "capacity";
-                "hardware-affinity": "hardware-affinity";
-                "co-located": "co-located";
-            }>;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Pin a device's audio analysis to a specific cluster node. */
         readonly assignAudio: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -673,33 +636,6 @@ export declare const pipelineOrchestratorCapability: {
             pinned: z.ZodBoolean;
             assignedAt: z.ZodNumber;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Get one camera's decoder placement (computed if not yet pinned).
-         *
-         * ADVISORY today: reports the orchestrator's decoder preference only.
-         * Actual decode placement is broker-owned (local-node pin + frame-plane
-         * co-location guard). Reserved to become the binding source/decoder-owner
-         * control in the stream-LB epic (Phase 2).
-         *
-         * `pipelineNodeId` is the node already chosen to run inference for
-         * this camera. When provided, the balancer prefers co-location with
-         * it; omitted → falls back to the last known assignment in the
-         * `assignments` map and finally to 'hub'.
-         */
-        readonly getDecoderAssignment: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            pipelineNodeId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            deviceId: z.ZodNumber;
-            decoderNodeId: z.ZodString;
-            pinned: z.ZodBoolean;
-            reason: z.ZodEnum<{
-                manual: "manual";
-                capacity: "capacity";
-                "hardware-affinity": "hardware-affinity";
-                "co-located": "co-located";
-            }>;
-        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Read one agent's settings. Null when not yet seeded. */
         readonly getAgentSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             agentNodeId: z.ZodString;
@@ -797,14 +733,15 @@ export declare const pipelineOrchestratorCapability: {
          * `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.
+         * other node → not). Detection/audio eligibility is derived from these
+         * flags across the cluster; changing them re-derives the enabled sets
+         * and reconciles dispatch immediately. There is NO separate decode flag:
+         * decode is always co-located with its frame consumer, so decode
+         * eligibility IS detect eligibility.
          */
         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<{
@@ -825,6 +762,31 @@ export declare const pipelineOrchestratorCapability: {
         }, 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
+         * dead persisted step-tree seed nothing in the live path read):
+         *   (a) strips every `modelId` pin from that node's
+         *       `agentSettings.addonDefaults` (cells revert to Auto — the node
+         *       resolves its own hardware-aware format default at runtime);
+         *   (b) clears per-camera step overrides scoped to that node
+         *       (`stepOverridesByAgent[node]` + the wholesale
+         *       `pipelineByAgent[node]` escape hatch);
+         *   (c) clears the executor-side per-device settings stores on that node
+         *       (`pipelineExecutor.clearDeviceOverrides`);
+         *   (d) hot-reloads every camera assigned to the node.
+         *
+         * Returns the EFFECTIVE post-reset object-detection model for the node
+         * (the executor's pure hardware-aware default) so the UI can report what
+         * will actually run — not a value that never reaches the live path.
+         */
+        readonly resetNodePipelineDefaults: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            agentNodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+            effectiveModelId: z.ZodNullable<z.ZodString>;
+            clearedCameraOverrides: z.ZodNumber;
+        }, 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;
@@ -1400,4 +1362,4 @@ export type CameraAudioStatus = z.infer<typeof CameraAudioStatusSchema>;
 export type CameraRecordingStatus = z.infer<typeof CameraRecordingStatusSchema>;
 export type CameraRecordingMode = z.infer<typeof CameraRecordingModeSchema>;
 export type IngestOwner = z.infer<typeof IngestOwnerSchema>;
-export { AgentLoadSummarySchema, CameraAssignmentStatusSchema, CameraAudioStatusSchema, CameraBrokerProfileSchema, CameraBrokerStatusSchema, CameraDecoderShmSchema, CameraDecoderStatusSchema, CameraDetectionPhaseSchema, CameraDetectionProvisioningSchema, CameraDetectionProvisioningStateSchema, CameraDetectionStatusSchema, CameraMotionStatusSchema, CameraPipelineConfigSchema, CameraRecordingModeSchema, CameraRecordingStatusSchema, CameraSourceStatusSchema, CameraSourceStreamSchema, CameraStatusSchema, CameraStepOverridePatchSchema, CapabilityBindingsSchema, DecoderAssignmentSchema, GlobalMetricsSchema, IngestOwnerSchema, PipelineAssignmentSchema, PipelineTemplateSchema as OrchestratorPipelineTemplateSchema, };
+export { AgentLoadSummarySchema, CameraAssignmentStatusSchema, CameraAudioStatusSchema, CameraBrokerProfileSchema, CameraBrokerStatusSchema, CameraDecoderShmSchema, CameraDecoderStatusSchema, CameraDetectionPhaseSchema, CameraDetectionProvisioningSchema, CameraDetectionProvisioningStateSchema, CameraDetectionStatusSchema, CameraMotionStatusSchema, CameraPipelineConfigSchema, CameraRecordingModeSchema, CameraRecordingStatusSchema, CameraSourceStatusSchema, CameraSourceStreamSchema, CameraStatusSchema, CameraStepOverridePatchSchema, CapabilityBindingsSchema, GlobalMetricsSchema, IngestOwnerSchema, PipelineAssignmentSchema, PipelineTemplateSchema as OrchestratorPipelineTemplateSchema, };

package/dist/device/index.d.ts

@@ -21,3 +21,5 @@ export { getByPath, setByPath } from './path-util.js';
 export { applyTransform } from './device-link-transform.js';
 export { enumerateItemArrayFields, enumerateSchemaFields } from './schema-fields.js';
 export type { WireableField } from './schema-fields.js';
+export { startReachabilityPoll, REACHABILITY_POLL_INTERVAL_MS, REACHABILITY_FAILURES_TO_OFFLINE, REACHABILITY_PROBE_TIMEOUT_MS, } from './reachability-poll.js';
+export type { ReachabilityPollOptions, ReachabilityPollHandle, ReachabilityPollLogger, } from './reachability-poll.js';

package/dist/device/reachability-poll.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Shared control-plane reachability poller for camera devices.
+ *
+ * `device.online` must reflect CONTROL-PLANE REACHABILITY — "can we talk to
+ * the camera's management API right now" — NOT whether video happens to be
+ * flowing through the stream broker. A camera that dials on-demand (no
+ * consumer attached) is fully reachable yet has no active stream; driving
+ * `online` from stream health falsely marks it OFFLINE.
+ *
+ * Every camera provider owns a cheap control-plane round-trip (Hikvision
+ * ISAPI `getDeviceInfo`, Amcrest Dahua CGI `getDeviceInfo`, ONVIF
+ * `getDeviceInformation`, RTSP `OPTIONS`/TCP-connect). Each provider passes
+ * that round-trip as a `probe: () => Promise<boolean>` and this helper runs
+ * the loop, applies hysteresis, and drives the device's `online` setter.
+ *
+ * Hysteresis rules (avoid flapping on a single dropped packet):
+ *   - mark ONLINE immediately on the first successful probe;
+ *   - mark OFFLINE only after {@link REACHABILITY_FAILURES_TO_OFFLINE}
+ *     CONSECUTIVE failures.
+ *
+ * Robustness rules:
+ *   - each probe is bounded by {@link REACHABILITY_PROBE_TIMEOUT_MS} so a hung
+ *     control channel can't wedge the loop;
+ *   - a single in-flight probe at a time — a slow probe never stacks up;
+ *   - the loop never throws (a rejected/thrown probe counts as a failure);
+ *   - `isEnabled()` gates each tick so a soft-disabled device isn't polled.
+ */
+/** Poll cadence — probe every camera's control plane on this interval. */
+export declare const REACHABILITY_POLL_INTERVAL_MS = 30000;
+/**
+ * Consecutive failures required before flipping `online` to `false`.
+ * ONLINE is asserted on the first success; OFFLINE waits for N misses so a
+ * single transient timeout doesn't flap the flag.
+ */
+export declare const REACHABILITY_FAILURES_TO_OFFLINE = 3;
+/** Per-probe timeout — an unreachable/hung control channel resolves as a miss. */
+export declare const REACHABILITY_PROBE_TIMEOUT_MS = 10000;
+/**
+ * Minimal logger surface the poller uses. Declared with METHOD syntax
+ * (not a property arrow) so the parameter check is bivariant — a scoped
+ * logger whose `debug` takes a structured `LogExtras` second argument
+ * satisfies this without the caller having to import the logger types.
+ */
+export interface ReachabilityPollLogger {
+    debug(message: string, meta?: unknown): void;
+}
+export interface ReachabilityPollOptions {
+    /**
+     * Control-plane round-trip. Resolve `true` when the camera is reachable,
+     * `false` (or throw/reject) when it is not. Never assume it resolves —
+     * the poller bounds it with a timeout regardless.
+     */
+    readonly probe: () => Promise<boolean>;
+    /**
+     * Drives the device's online flag — typically `(v) => { device.online = v }`
+     * or `device.markOnline`. Called only on an actual transition decision
+     * (idempotent setters are fine; `markOnline` already no-ops on no-change).
+     */
+    readonly setOnline: (online: boolean) => void;
+    /**
+     * Gate for each tick. Return `false` to skip the probe entirely (e.g. a
+     * soft-disabled device, or a sleeping battery camera). Default: always on.
+     * A skipped tick does NOT count as a failure and leaves `online` untouched.
+     */
+    readonly isEnabled?: () => boolean;
+    /** Override the 30s cadence (tests). */
+    readonly intervalMs?: number;
+    /** Override the 3-miss offline threshold (tests). */
+    readonly failuresToOffline?: number;
+    /** Override the 10s per-probe timeout (tests). */
+    readonly probeTimeoutMs?: number;
+    /** Optional scoped logger for probe-failure diagnostics. */
+    readonly logger?: ReachabilityPollLogger;
+    /**
+     * Run the first probe immediately instead of waiting one interval.
+     * Default `true` — a freshly-activated camera should reflect reachability
+     * without a 30s blind window.
+     */
+    readonly runImmediately?: boolean;
+}
+export interface ReachabilityPollHandle {
+    /** Stop the loop and release the timer. Idempotent. */
+    readonly stop: () => void;
+}
+/**
+ * Start the reachability poll loop. Returns a handle whose `stop()` clears the
+ * timer and prevents any further ticks. Start on device activation, stop on
+ * device teardown (`removeDevice`) so no timer leaks.
+ */
+export declare function startReachabilityPoll(options: ReachabilityPollOptions): ReachabilityPollHandle;