@camstack/types 1.2.41 → 1.2.43

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-BE4PDZ_3.js");
-const require_sleep = require("./sleep-DTce7-ch.js");
+const require_sleep = require("./sleep-Bx9IIoT0.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/collection-array-methods.ts
 /**

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-41fKf-q9.mjs";
-import { B as scopeKey, C as DeviceType, F as readNodePin, I as ReadinessRegistry, L as ReadinessTimeoutError, O as expandCapMethods, P as nodePin, a as asJsonObject, d as DEVICE_SCOPED_CAPS, f as isDeviceScopedCap, ft as DATAPLANE_SECRET_HEADER, ht as normalizeAddonInitResult, mt as BaseAddon, p as createDeviceProxy, pt as DisposerChain, s as asString, t as sleep, u as parseJsonUnknown, v as deviceOpsCapability, vt as emitReadiness, w as adminUiCapability, y as viewerUiCapability } from "./sleep-CXimb854.mjs";
+import { C as DeviceType, F as readNodePin, L as ReadinessRegistry, O as expandCapMethods, P as nodePin, R as ReadinessTimeoutError, V as scopeKey, a as asJsonObject, d as DEVICE_SCOPED_CAPS, f as isDeviceScopedCap, gt as normalizeAddonInitResult, ht as BaseAddon, mt as DisposerChain, p as createDeviceProxy, pt as DATAPLANE_SECRET_HEADER, s as asString, t as sleep, u as parseJsonUnknown, v as deviceOpsCapability, w as adminUiCapability, y as viewerUiCapability, yt as emitReadiness } from "./sleep-DtstvzWm.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/collection-array-methods.ts
 /**

package/dist/canonical-hash-7nfBbEqR.mjs

@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+//#region src/utils/canonical-hash.ts
+/**
+* Deterministic SHA-256 hash of an arbitrary serialisable value. The
+* canonical form sorts object keys alphabetically at every depth so two
+* structurally-equal inputs with different key insertion orders produce
+* the same hash. Returns a 64-char lowercase hex digest.
+*
+* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
+* accessory-rebuild work when the upstream shape is byte-identical to
+* the last applied state — preventing user-visible "re-discovery"
+* notifications on every addon-runner respawn. Each respawn re-fires
+* `DeviceBindingsChanged` for every cap registration, which without
+* this guard would propagate redundant pushes.
+*
+* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
+* subscription. The proper fix is a single "device ready" lifecycle
+* barrier so exports react only when the full cap set has landed —
+* tracked separately for post-HA-integration work.
+*/
+function canonicalHash(value) {
+	const canonical = JSON.stringify(value, replaceWithSortedKeys);
+	return createHash("sha256").update(canonical ?? "").digest("hex");
+}
+function replaceWithSortedKeys(_key, value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const obj = value;
+		const out = {};
+		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
+		return out;
+	}
+	return value;
+}
+//#endregion
+export { canonicalHash as t };

package/dist/canonical-hash-BcZHRHIx.js

@@ -0,0 +1,40 @@
+let node_crypto = require("node:crypto");
+//#region src/utils/canonical-hash.ts
+/**
+* Deterministic SHA-256 hash of an arbitrary serialisable value. The
+* canonical form sorts object keys alphabetically at every depth so two
+* structurally-equal inputs with different key insertion orders produce
+* the same hash. Returns a 64-char lowercase hex digest.
+*
+* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
+* accessory-rebuild work when the upstream shape is byte-identical to
+* the last applied state — preventing user-visible "re-discovery"
+* notifications on every addon-runner respawn. Each respawn re-fires
+* `DeviceBindingsChanged` for every cap registration, which without
+* this guard would propagate redundant pushes.
+*
+* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
+* subscription. The proper fix is a single "device ready" lifecycle
+* barrier so exports react only when the full cap set has landed —
+* tracked separately for post-HA-integration work.
+*/
+function canonicalHash(value) {
+	const canonical = JSON.stringify(value, replaceWithSortedKeys);
+	return (0, node_crypto.createHash)("sha256").update(canonical ?? "").digest("hex");
+}
+function replaceWithSortedKeys(_key, value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const obj = value;
+		const out = {};
+		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
+		return out;
+	}
+	return value;
+}
+//#endregion
+Object.defineProperty(exports, "canonicalHash", {
+	enumerable: true,
+	get: function() {
+		return canonicalHash;
+	}
+});

package/dist/cap-call-context.d.ts

@@ -28,8 +28,34 @@ export interface NodePinnedRequestOptions {
 /**
  * Build the tRPC request options that pin a single capability call to `nodeId`.
  * Pass as the second argument to `.query(input, …)` / `.mutate(input, …)`.
+ *
+ * ## The id is normalised here, and it has to be
+ *
+ * A forked addon reads its own node from `ctx.kernel.localNodeId`, and inside a
+ * worker that value is a RUNNER id — `hub/export-hap`, not `hub`. Routing
+ * compares a pin against real node ids, so such a pin matches nothing and the
+ * call fails with `no provider registered for cap "…"`. The local-first
+ * resolver already guarded against this (`localNodeId.split('/')[0]`), which
+ * made the hazard invisible: unpinned calls worked, and only an explicit pin —
+ * the thing you reach for when you specifically need THIS node — silently
+ * addressed a node that does not exist.
+ *
+ * Cost of it being missing: `addon-export-hap` pinned `decoder.getInfo` to its
+ * own node to read the host's hardware-decode backend. It never once answered,
+ * so every HomeKit egress transcode decoded in SOFTWARE — including 4K H.265 —
+ * while D67's whole premise was that the decoder addon is the authority on
+ * hardware. The warn said `decoding in SOFTWARE` and read as "this node has no
+ * hardware", which was false.
+ *
+ * Normalising in the ONE constructor fixes every caller at once, which is why
+ * it is here and not at the call sites.
  */
 export declare function nodePin(nodeId: string): NodePinnedRequestOptions;
+/**
+ * A runner id is `<nodeId>/<addonId>`; a node id has no slash. Taking the head
+ * is idempotent, so passing an already-clean id costs nothing.
+ */
+export declare function toNodeId(idOrRunnerId: string): string;
 /**
  * Read a per-call node pin out of a tRPC `op.context` (transport side).
  * Returns the pinned nodeId, or `undefined` when no pin is present.

package/dist/capabilities/index.d.ts

@@ -76,12 +76,12 @@ export { NetworkAccessStatusSchema, NetworkEndpointSchema, networkAccessCapabili
 export { type Attachment, type AttachmentMediaType, AttachmentMediaTypeSchema, AttachmentSchema, type DiscoveredTarget, DiscoveredTargetSchema, type INotificationOutputProvider, type NotificationAction, type NotificationActionIcon, NotificationActionIconSchema, NotificationActionSchema, type NotificationFormat, NotificationFormatSchema, NotificationSchema, notificationOutputCapability, type RenderedAs, RenderedAsSchema, type SendResult, SendResultSchema, type Target, type TargetKind, type TargetKindCaps, TargetKindCapsSchema, type TargetKindLevel, TargetKindLevelSchema, TargetKindSchema, TargetSchema, type TestResult, TestResultSchema, } from './notification-output.cap.js';
 export { type INotificationRulesProvider, NC_CONDITION_CATALOG, NC_HISTORY_LIMIT_DEFAULT, NC_HISTORY_LIMIT_MAX, NC_MAX_PER_TRACK_IMMEDIATE, NC_SNOOZE_MAX_MINUTES, type NcAlarmConfig, NcAlarmConfigSchema, type NcAlarmModeCoverage, NcAlarmModeCoverageSchema, type NcAlarmSettings, type NcAlarmSettingsPatch, NcAlarmSettingsPatchSchema, NcAlarmSettingsSchema, type NcConditionDescriptor, NcConditionDescriptorSchema, type NcConditions, NcConditionsSchema, type NcCrossing, NcCrossingSchema, type NcDelivery, NcDeliverySchema, type NcDeviceStateCondition, NcDeviceStateConditionSchema, type NcHistoryEntry, NcHistoryEntrySchema, type NcHistoryFilter, NcHistoryFilterSchema, type NcHistoryRecordKind, NcHistoryRecordKindSchema, type NcHistoryStatus, NcHistoryStatusSchema, type NcHistorySubject, NcHistorySubjectSchema, type NcMediaFrame, NcMediaFrameSchema, type NcMediaPolicy, NcMediaPolicySchema, type NcOccupancyCondition, NcOccupancyConditionSchema, type NcPlateMatcher, NcPlateMatcherSchema, type NcRule, type NcRuleAction, NcRuleActionSchema, type NcRuleActionSequence, NcRuleActionSequenceSchema, type NcRuleActions, NcRuleActionsSchema, type NcRuleInput, NcRuleInputSchema, type NcRuleNotificationButton, NcRuleNotificationButtonSchema, type NcRulePatch, NcRulePatchSchema, NcRuleSchema, type NcRuleTarget, NcRuleTargetSchema, type NcSchedule, NcScheduleSchema, type NcScheduleWindow, NcScheduleWindowSchema, type NcSnooze, type NcSnoozeInput, NcSnoozeInputSchema, NcSnoozeSchema, type NcSnoozeScope, NcSnoozeScopeSchema, type NcSnoozeSuppressed, NcSnoozeSuppressedSchema, type NcTestResult, NcTestResultSchema, type NcThrottle, type NcThrottleGranularity, NcThrottleGranularitySchema, NcThrottleSchema, type NcZoneCondition, NcZoneConditionSchema, notificationRulesCapability, } from './notification-rules.cap.js';
 export { type IOauthIntegrationProvider, type OauthIntegrationDescriptor, OauthIntegrationDescriptorSchema, oauthIntegrationCapability, } from './oauth-integration.cap.js';
-export { type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type EventKindsForDevice, EventKindsForDeviceSchema, type EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type MediaFile, type MediaFileInfo, MediaFileInfoSchema, type MediaFileKind, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type RecentTracksPage, RecentTracksPageSchema, type RecentTracksQuery, RecentTracksQueryInput, type ScoredObjectEvent, ScoredObjectEventSchema, type SensorEvent, SensorEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, type TrackEnvelope, TrackEnvelopeSchema, TrackedDetectionSchema, type TrackProjection, TrackProjectionSchema, TrackSchema, type TrackState, TrackStateSchema, type TrackZoneFilter, TrackZoneFilterSchema, type ZoneCrossing, type ZoneCrossingDirection, ZoneCrossingDirectionSchema, ZoneCrossingSchema, } from './pipeline-analytics.cap.js';
+export { type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type EventKindsForDevice, EventKindsForDeviceSchema, type EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type MediaFile, type MediaFileInfo, MediaFileInfoSchema, type MediaFileKind, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type RecentTracksPage, RecentTracksPageSchema, type RecentTracksQuery, RecentTracksQueryInput, type ScoredObjectEvent, ScoredObjectEventSchema, type SensorEvent, SensorEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, type TrackEnvelope, TrackEnvelopeSchema, TrackedDetectionSchema, type TrackFlags, type TrackFlagsPatch, TrackFlagsPatchSchema, TrackFlagsSchema, type TrackProjection, TrackProjectionSchema, TrackSchema, type TrackSource, TrackSourceSchema, type TrackState, TrackStateSchema, type TrackZoneFilter, TrackZoneFilterSchema, type ZoneCrossing, type ZoneCrossingDirection, ZoneCrossingDirectionSchema, ZoneCrossingSchema, } from './pipeline-analytics.cap.js';
 export type { NativeCropRef, PipelineStepInputOutput, PipelineValidationIssue, PipelineValidationResult, } from './pipeline-executor.cap.js';
 export { ModelSubstitutionSchema, NativeCropRefSchema, 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, NodeInferenceDevice, NodeInferenceDevices, } 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 { DetailParent, DetailResult, MotionSource, MotionSources, ReportMotionInput, RunDetailSubtreeInput, RunDetailSubtreeResult, RunnerFrameSource, RunnerInferenceDevice, } from './pipeline-runner.cap.js';
+export type { DetailParent, DetailResult, MotionSource, MotionSources, ReportMotionInput, RunDetailSubtreeInput, RunDetailSubtreeResult, RunnerFrameSource, RunnerInferenceDevice, RunStatelessStepInput, RunStatelessStepResult, StatelessStepRefusal, } from './pipeline-runner.cap.js';
 export { MotionSourceEnum, MotionSourcesSchema, NativeCropBboxSchema, NativeCropResultSchema, pipelineRunnerCapability, ReportMotionInputSchema, RunnerCameraConfigSchema, RunnerCameraDeviceUIFields, RunnerFrameSourceSchema, RunnerInferenceDeviceSchema, RunnerLocalLoadSchema, RunnerLocalMetricsSchema, } from './pipeline-runner.cap.js';
 export { AudioChunkInputSchema, AudioClassificationLabelSchema, AudioLevelSchema, BoundingBoxSchema, FrameInputSchema, SpatialDetectionSchema, } from './schemas/detection-shared.js';
 export { CameraMetricsSchema, CameraMetricsWithDeviceIdSchema, OrchestratorMetricsSchema, } from './schemas/orchestrator-metrics.js';
@@ -99,7 +99,7 @@ export { type IStorageCapProvider, StorageLocationTypeSchema, storageCapability,
 export { type EvictableUsage, type EvictResult, type IStorageEvictableProvider, storageEvictableCapability, } from './storage-evictable.cap.js';
 export { AbortUploadInputSchema as StorageAbortUploadInputSchema, BeginDownloadInputSchema as StorageBeginDownloadInputSchema, BeginDownloadResultSchema as StorageBeginDownloadResultSchema, BeginUploadInputSchema as StorageBeginUploadInputSchema, BeginUploadResultSchema as StorageBeginUploadResultSchema, EndDownloadInputSchema as StorageEndDownloadInputSchema, FinalizeUploadInputSchema as StorageFinalizeUploadInputSchema, type IStorageProviderImpl, ProviderInfoSchema as StorageProviderInfoSchema, ReadChunkInputSchema as StorageReadChunkInputSchema, storageProviderCapability, TestLocationResultSchema as StorageTestLocationResultSchema, WriteChunkInputSchema as StorageWriteChunkInputSchema, } from './storage-provider.cap.js';
 export type { AudioCodecTarget, BrokerAudioClient, BrokerClients, BrokerConsumerAttribution, BrokerConsumerKind, BrokerDecodedClient, BrokerEncodedClient, BrokerRtspClient, GetStreamWithCodecInput, PlaceholderReason, RtpSource, VideoCodecTarget, } from './stream-broker.cap.js';
-export { BrokerAudioClientSchema, BrokerClientsSchema, BrokerConsumerAttributionSchema, BrokerConsumerKindSchema, BrokerDecodedClientSchema, BrokerEncodedClientSchema, BrokerRtspClientSchema, GetStreamWithCodecInputSchema, PlaceholderReasonSchema, RtpSourceSchema, RtspRestreamEntrySchema, type StreamBrokerClient, type StreamFormat, StreamFormatSchema, streamBrokerCapability, } from './stream-broker.cap.js';
+export { BrokerAudioClientSchema, BrokerClientsSchema, BrokerConsumerAttributionSchema, BrokerConsumerKindSchema, BrokerDecodedClientSchema, BrokerEncodedClientSchema, BrokerRtspClientSchema, type EgressEncode, EgressEncodeSchema, type EgressRateControl, EgressRateControlSchema, type EgressTranscode, type EgressTranscodeRequest, EgressTranscodeRequestSchema, EgressTranscodeSchema, GetStreamWithCodecInputSchema, PlaceholderReasonSchema, RtpSourceSchema, RtspRestreamEntrySchema, type StreamBrokerClient, type StreamFormat, StreamFormatSchema, streamBrokerCapability, } from './stream-broker.cap.js';
 export { type ITerminalSessionProvider, type TerminalProfileInfo, TerminalProfileInfoSchema, type TerminalSessionInfo, TerminalSessionInfoSchema, terminalSessionCapability, } from './terminal-session.cap.js';
 export type { ITurnProvider } from './turn-provider.cap.js';
 export { TurnServerSchema, turnProviderCapability } from './turn-provider.cap.js';
@@ -172,11 +172,11 @@ export { type HardwareDecodeAccels, type HardwareEncoderId, type HardwareEncoder
 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';
-export { type IPrivacyMaskProvider, type PrivacyMaskOptions, PrivacyMaskOptionsSchema, type PrivacyMaskPatch, PrivacyMaskPatchSchema, type PrivacyMaskRegion, PrivacyMaskRegionSchema, type PrivacyMaskShape, PrivacyMaskShapeSchema, type PrivacyMaskStatus, PrivacyMaskStatusSchema, privacyMaskCapability, } from './privacy-mask.cap.js';
+export { type IPrivacyMaskProvider, type PrivacyMaskOptions, PrivacyMaskOptionsSchema, type PrivacyMaskPatch, PrivacyMaskPatchSchema, type PrivacyMaskRegion, PrivacyMaskRegionSchema, type PrivacyMaskShape, PrivacyMaskShapeSchema, type PrivacyMaskStatus, PrivacyMaskStatusSchema, privacyMaskCapability, summarisePrivacyAudio, } from './privacy-mask.cap.js';
 export { type IPtzProvider, PtzMoveCommandSchema, type PtzOptions, PtzOptionsSchema, PtzPositionSchema, PtzPresetSchema, type PtzStatus, PtzStatusSchema, ptzCapability, } from './ptz.cap.js';
 export { type IPtzAutotrackProvider, type PtzAutotrackRuntimeState, PtzAutotrackRuntimeStateSchema, type PtzAutotrackSettings, PtzAutotrackSettingsSchema, type PtzAutotrackStatus, PtzAutotrackStatusSchema, type PtzAutotrackTargetOption, PtzAutotrackTargetOptionSchema, ptzAutotrackCapability, } from './ptz-autotrack.cap.js';
 export { type IRebootProvider, rebootCapability } from './reboot.cap.js';
-export { type IRecordingProvider, type LocateSegmentResult, LocateSegmentResultSchema, type ReadSegmentBytesResult, ReadSegmentBytesResultSchema, type RecordingAvailability, RecordingAvailabilitySchema, type RecordingDays, RecordingDaysSchema, type RecordingDeviceUsage, RecordingDeviceUsageSchema, type RecordingLocationUsage, RecordingLocationUsageSchema, type RecordingManifest, RecordingManifestSchema, RecordingRangeSchema, type RecordingStatus, RecordingStatusSchema, type RecordingStorageUsage, RecordingStorageUsageSchema, recordingCapability, } from './recording.cap.js';
+export { type IRecordingProvider, type LocateSegmentResult, LocateSegmentResultSchema, type ReadGopBytesResult, ReadGopBytesResultSchema, type ReadSegmentBytesResult, ReadSegmentBytesResultSchema, type RecordingAvailability, RecordingAvailabilitySchema, type RecordingDays, RecordingDaysSchema, type RecordingDeviceUsage, RecordingDeviceUsageSchema, type RecordingLocationUsage, RecordingLocationUsageSchema, type RecordingManifest, RecordingManifestSchema, RecordingRangeSchema, type RecordingStatus, RecordingStatusSchema, type RecordingStorageUsage, RecordingStorageUsageSchema, recordingCapability, } from './recording.cap.js';
 export { type ExportDownload, ExportDownloadSchema, type ExportOptions, ExportOptionsSchema, type ExportRecord, ExportRecordSchema, ExportSpeedSchema, type ExportState, ExportStateSchema, ExportTimelapseSchema, type IRecordingExportProvider, recordingExportCapability, } from './recording-export.cap.js';
 export { type ISceneMonitorProvider, type SceneCheck, SceneCheckSchema, type SceneCondition, SceneConditionSchema, type SceneMonitor, SceneMonitorSchema, type SceneMonitorState, SceneMonitorStateSchema, type SceneMonitorStatus, SceneMonitorStatusSchema, type SceneReference, SceneReferenceSchema, sceneMonitorCapability, } from './scene-monitor.cap.js';
 export { type ZoneRule, type ZoneRuleMode, ZoneRuleModeEnum, ZoneRuleSchema, type ZoneRules, ZoneRulesArraySchema, } from './schemas/zone-rule.js';

package/dist/capabilities/notification-rules.cap.d.ts

@@ -334,6 +334,7 @@ export declare const NcConditionsSchema: z.ZodObject<{
     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
     source: z.ZodOptional<z.ZodEnum<{
         sensor: "sensor";
+        audio: "audio";
         any: "any";
         pipeline: "pipeline";
         onboard: "onboard";
@@ -500,6 +501,7 @@ export declare const NcRuleInputSchema: z.ZodObject<{
         minDwellSeconds: z.ZodOptional<z.ZodNumber>;
         source: z.ZodOptional<z.ZodEnum<{
             sensor: "sensor";
+            audio: "audio";
             any: "any";
             pipeline: "pipeline";
             onboard: "onboard";
@@ -679,6 +681,7 @@ export declare const NcRulePatchSchema: z.ZodObject<{
         minDwellSeconds: z.ZodOptional<z.ZodNumber>;
         source: z.ZodOptional<z.ZodEnum<{
             sensor: "sensor";
+            audio: "audio";
             any: "any";
             pipeline: "pipeline";
             onboard: "onboard";
@@ -851,6 +854,7 @@ export declare const NcRuleSchema: z.ZodObject<{
         minDwellSeconds: z.ZodOptional<z.ZodNumber>;
         source: z.ZodOptional<z.ZodEnum<{
             sensor: "sensor";
+            audio: "audio";
             any: "any";
             pipeline: "pipeline";
             onboard: "onboard";
@@ -1343,6 +1347,7 @@ export declare const notificationRulesCapability: {
                     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
                     source: z.ZodOptional<z.ZodEnum<{
                         sensor: "sensor";
+                        audio: "audio";
                         any: "any";
                         pipeline: "pipeline";
                         onboard: "onboard";
@@ -1521,6 +1526,7 @@ export declare const notificationRulesCapability: {
                     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
                     source: z.ZodOptional<z.ZodEnum<{
                         sensor: "sensor";
+                        audio: "audio";
                         any: "any";
                         pipeline: "pipeline";
                         onboard: "onboard";
@@ -1697,6 +1703,7 @@ export declare const notificationRulesCapability: {
                     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
                     source: z.ZodOptional<z.ZodEnum<{
                         sensor: "sensor";
+                        audio: "audio";
                         any: "any";
                         pipeline: "pipeline";
                         onboard: "onboard";
@@ -1867,6 +1874,7 @@ export declare const notificationRulesCapability: {
                     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
                     source: z.ZodOptional<z.ZodEnum<{
                         sensor: "sensor";
+                        audio: "audio";
                         any: "any";
                         pipeline: "pipeline";
                         onboard: "onboard";
@@ -2046,6 +2054,7 @@ export declare const notificationRulesCapability: {
                     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
                     source: z.ZodOptional<z.ZodEnum<{
                         sensor: "sensor";
+                        audio: "audio";
                         any: "any";
                         pipeline: "pipeline";
                         onboard: "onboard";
@@ -2217,6 +2226,7 @@ export declare const notificationRulesCapability: {
                     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
                     source: z.ZodOptional<z.ZodEnum<{
                         sensor: "sensor";
+                        audio: "audio";
                         any: "any";
                         pipeline: "pipeline";
                         onboard: "onboard";
@@ -2363,6 +2373,36 @@ export declare const notificationRulesCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * PERMANENT per-camera mute — the notifications half of the per-camera
+         * function switch group ([D61](../../../../docs/decisions/adr-0067.md)).
+         *
+         * Deliberately NOT a snooze. A snooze is bounded at
+         * {@link NC_SNOOZE_MAX_MINUTES} on purpose — "a snooze that could not
+         * expire would be an outage the operator asked for once and forgot" — and
+         * widening it to express "this camera never notifies" would destroy that
+         * property for every snooze. A mute is the other thing: an explicit,
+         * indefinite, admin-only decision, visible in the switch group next to the
+         * other four, and reported on `CameraStatus.switchedOff` so a silent
+         * camera never reads as a working one.
+         *
+         * Returned as ONE list rather than a per-camera query: the group's reader
+         * needs every camera's state, and a per-camera fan-out over the viewer's
+         * single WebSocket is N frames serialised on one socket.
+         */
+        readonly listDeviceMutes: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            mutedDeviceIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Mute or unmute one camera. Idempotent; an unmute of a camera that was
+         * never muted succeeds.
+         */
+        readonly setDeviceMuted: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            muted: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
         /**
          * Dry-run a rule against recently persisted records (object events for
          * `immediate`, closed tracks for `track-end`). Mutation kind only to
@@ -2411,6 +2451,7 @@ export declare const notificationRulesCapability: {
                     minDwellSeconds: z.ZodOptional<z.ZodNumber>;
                     source: z.ZodOptional<z.ZodEnum<{
                         sensor: "sensor";
+                        audio: "audio";
                         any: "any";
                         pipeline: "pipeline";
                         onboard: "onboard";

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

@@ -229,17 +229,48 @@ declare const TrackAudioLabelSchema: z.ZodObject<{
 export type TrackAudioLabel = z.infer<typeof TrackAudioLabelSchema>;
 /**
  * How a track was produced. `pipeline` (default / absent) = the spatial
- * detection+tracking pipeline. `sensor` = a SYNTHETIC track projected from a
- * linked sensor/control state change (no positions; carries a snapshot). The
- * spatial subsystems (tracker association, occupancy count, re-id/embedding,
- * resurrection) MUST skip `sensor` tracks — they have no bbox trajectory.
+ * detection+tracking pipeline. Every OTHER value is a SYNTHETIC projection —
+ * no positions, a single snapshot, and no bbox trajectory at all:
+ *
+ *  - `sensor` — a linked sensor/control device state change.
+ *  - `audio` — an audio event on the camera itself that was anomalous for
+ *    THAT camera, loud, and heard while nothing visual was happening (D62).
+ *
+ * The spatial subsystems (tracker association, occupancy count, re-id /
+ * embedding, resurrection) MUST skip every synthetic source. Test for that
+ * with `isSpatialTrack`, which allow-lists `pipeline` — a `!== 'sensor'`
+ * check silently readmits every source added after it was written.
  */
 export declare const TrackSourceSchema: z.ZodEnum<{
     sensor: "sensor";
+    audio: "audio";
     pipeline: "pipeline";
 }>;
 export type TrackSource = z.infer<typeof TrackSourceSchema>;
+/**
+ * The write half: a PARTIAL patch. An omitted key is left untouched, so setting
+ * one flag can never clear the other — the toggles are independent and are
+ * driven from three surfaces that do not know about each other.
+ */
+export declare const TrackFlagsPatchSchema: z.ZodObject<{
+    markForTrain: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TrackFlagsPatch = z.infer<typeof TrackFlagsPatchSchema>;
+/**
+ * The resolved flag state after a write. Both fields are REQUIRED here (absent
+ * collapses to `false`) so a caller can drive a toggle's checked state off the
+ * mutation result without a re-fetch.
+ */
+export declare const TrackFlagsSchema: z.ZodObject<{
+    trackId: z.ZodString;
+    markForTrain: z.ZodBoolean;
+    debug: z.ZodBoolean;
+}, z.core.$strip>;
+export type TrackFlags = z.infer<typeof TrackFlagsSchema>;
 declare const TrackSchema: z.ZodObject<{
+    markForTrain: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodBoolean>;
     trackId: z.ZodString;
     deviceId: z.ZodNumber;
     className: z.ZodString;
@@ -247,6 +278,7 @@ declare const TrackSchema: z.ZodObject<{
     producingDeviceName: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodEnum<{
         sensor: "sensor";
+        audio: "audio";
         pipeline: "pipeline";
     }>>;
     firstSeen: z.ZodNumber;
@@ -518,6 +550,8 @@ declare const RecentTracksQueryInput: z.ZodObject<{
 export type RecentTracksQuery = z.infer<typeof RecentTracksQueryInput>;
 declare const RecentTracksPageSchema: z.ZodObject<{
     tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        markForTrain: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
         trackId: z.ZodString;
         deviceId: z.ZodNumber;
         className: z.ZodString;
@@ -525,6 +559,7 @@ declare const RecentTracksPageSchema: z.ZodObject<{
         producingDeviceName: z.ZodOptional<z.ZodString>;
         source: z.ZodOptional<z.ZodEnum<{
             sensor: "sensor";
+            audio: "audio";
             pipeline: "pipeline";
         }>>;
         firstSeen: z.ZodNumber;
@@ -587,6 +622,8 @@ declare const RecentTracksPageSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type RecentTracksPage = z.infer<typeof RecentTracksPageSchema>;
 declare const KeyEventSchema: z.ZodObject<{
+    markForTrain: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodBoolean>;
     id: z.ZodString;
     trackId: z.ZodString;
     timestamp: z.ZodNumber;
@@ -707,6 +744,8 @@ export declare const pipelineAnalyticsCapability: {
         readonly getActiveTracks: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            markForTrain: z.ZodOptional<z.ZodBoolean>;
+            debug: z.ZodOptional<z.ZodBoolean>;
             trackId: z.ZodString;
             deviceId: z.ZodNumber;
             className: z.ZodString;
@@ -714,6 +753,7 @@ export declare const pipelineAnalyticsCapability: {
             producingDeviceName: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<{
                 sensor: "sensor";
+                audio: "audio";
                 pipeline: "pipeline";
             }>>;
             firstSeen: z.ZodNumber;
@@ -776,6 +816,8 @@ export declare const pipelineAnalyticsCapability: {
             deviceId: z.ZodNumber;
             trackId: z.ZodString;
         }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            markForTrain: z.ZodOptional<z.ZodBoolean>;
+            debug: z.ZodOptional<z.ZodBoolean>;
             trackId: z.ZodString;
             deviceId: z.ZodNumber;
             className: z.ZodString;
@@ -783,6 +825,7 @@ export declare const pipelineAnalyticsCapability: {
             producingDeviceName: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<{
                 sensor: "sensor";
+                audio: "audio";
                 pipeline: "pipeline";
             }>>;
             firstSeen: z.ZodNumber;
@@ -867,6 +910,8 @@ export declare const pipelineAnalyticsCapability: {
                 slim: "slim";
             }>>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            markForTrain: z.ZodOptional<z.ZodBoolean>;
+            debug: z.ZodOptional<z.ZodBoolean>;
             trackId: z.ZodString;
             deviceId: z.ZodNumber;
             className: z.ZodString;
@@ -874,6 +919,7 @@ export declare const pipelineAnalyticsCapability: {
             producingDeviceName: z.ZodOptional<z.ZodString>;
             source: z.ZodOptional<z.ZodEnum<{
                 sensor: "sensor";
+                audio: "audio";
                 pipeline: "pipeline";
             }>>;
             firstSeen: z.ZodNumber;
@@ -954,6 +1000,8 @@ export declare const pipelineAnalyticsCapability: {
             }>>;
         }, z.core.$strip>, z.ZodObject<{
             tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                markForTrain: z.ZodOptional<z.ZodBoolean>;
+                debug: z.ZodOptional<z.ZodBoolean>;
                 trackId: z.ZodString;
                 deviceId: z.ZodNumber;
                 className: z.ZodString;
@@ -961,6 +1009,7 @@ export declare const pipelineAnalyticsCapability: {
                 producingDeviceName: z.ZodOptional<z.ZodString>;
                 source: z.ZodOptional<z.ZodEnum<{
                     sensor: "sensor";
+                    audio: "audio";
                     pipeline: "pipeline";
                 }>>;
                 firstSeen: z.ZodNumber;
@@ -1274,6 +1323,8 @@ export declare const pipelineAnalyticsCapability: {
             minImportance: z.ZodOptional<z.ZodNumber>;
             classFilter: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            markForTrain: z.ZodOptional<z.ZodBoolean>;
+            debug: z.ZodOptional<z.ZodBoolean>;
             id: z.ZodString;
             trackId: z.ZodString;
             timestamp: z.ZodNumber;
@@ -1370,6 +1421,37 @@ export declare const pipelineAnalyticsCapability: {
             deleted: z.ZodNumber;
             failed: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Set the per-track operator flags (`markForTrain`, `debug`) on ONE track.
+         * The patch is PARTIAL — an omitted key is left untouched — because the
+         * three surfaces that write it (admin Events grid, viewer track detail,
+         * viewer cluster detail) each own one toggle and must not clobber the other.
+         *
+         * Writes the track ROW: `markForTrain`/`debug` are per-TRACK state, so they
+         * live where `label` and `importance` live, not in any per-device settings
+         * store. Updates the in-RAM active track too, so a flag set on a live track
+         * survives its expiry-time persist.
+         *
+         * `auth: 'protected'` (the default), NOT `admin`: the viewer is an
+         * authenticated non-admin surface and two of the three call sites are
+         * there. Revisit if a flag ever gains an effect that costs storage —
+         * `deleteTracks` next door is admin for exactly that reason.
+         *
+         * Returns the RESOLVED state of both flags (absent → `false`) so a caller
+         * can drive its toggle without a re-fetch. Rejects an unknown track.
+         */
+        readonly setTrackFlags: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            trackId: z.ZodString;
+            flags: z.ZodObject<{
+                markForTrain: z.ZodOptional<z.ZodBoolean>;
+                debug: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            trackId: z.ZodString;
+            markForTrain: z.ZodBoolean;
+            debug: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
         /**
          * Durable event-store footprint for the management UI: event rows
          * (motion + object + audio) counted per camera + total, plus the
@@ -1398,6 +1480,7 @@ export declare const pipelineAnalyticsCapability: {
                 operator: "operator";
                 retention: "retention";
                 quota: "quota";
+                maintenance: "maintenance";
             }>>;
         }, z.core.$strip>, z.ZodObject<{
             motion: z.ZodNumber;
@@ -1471,12 +1554,14 @@ export declare const pipelineAnalyticsCapability: {
                 rescan: "rescan";
                 "retention-run": "retention-run";
                 relocate: "relocate";
+                "orphan-audit": "orphan-audit";
             }>;
             reason: z.ZodEnum<{
                 manual: "manual";
                 operator: "operator";
                 retention: "retention";
                 quota: "quota";
+                maintenance: "maintenance";
             }>;
             deviceId: z.ZodNullable<z.ZodNumber>;
             nodeId: z.ZodString;
@@ -1665,6 +1750,8 @@ export declare const pipelineAnalyticsCapability: {
             since: z.ZodOptional<z.ZodNumber>;
             until: z.ZodOptional<z.ZodNumber>;
             maxTracks: z.ZodOptional<z.ZodNumber>;
+            executeOnNodeId: z.ZodOptional<z.ZodString>;
+            pacingMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
             started: z.ZodBoolean;
             alreadyRunning: z.ZodBoolean;
@@ -1676,6 +1763,7 @@ export declare const pipelineAnalyticsCapability: {
             missingKeyFrame: z.ZodNumber;
             missingBbox: z.ZodNumber;
             notRunnable: z.ZodNumber;
+            noCapableNode: z.ZodNumber;
             failed: z.ZodNumber;
             complete: z.ZodNullable<z.ZodBoolean>;
             startedAtMs: z.ZodNullable<z.ZodNumber>;