@camstack/types 1.2.17 → 1.2.19

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-yfPaamGa.js");
-const require_event_category = require("./event-category-Cdyife4p.js");
+const require_sleep = require("./sleep-mkNQLVPE.js");
+const require_event_category = require("./event-category-39bpf1r_.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 { A as parseJsonUnknown, Ct as DisposerChain, D as asString, F as ReadinessRegistry, I as ReadinessTimeoutError, M as nodePin, N as readNodePin, P as DATAPLANE_SECRET_HEADER, S as DeviceType, T as asJsonObject, a as viewerUiCapability, dt as BaseAddon, ft as normalizeAddonInitResult, ht as emitReadiness, i as deviceOpsCapability, m as expandCapMethods, o as adminUiCapability, s as createDeviceProxy, t as sleep, z as scopeKey } from "./sleep-Ct4Is70g.mjs";
-import { t as EventCategory } from "./event-category-BLcNejAE.mjs";
+import { A as parseJsonUnknown, Ct as DisposerChain, D as asString, F as ReadinessRegistry, I as ReadinessTimeoutError, M as nodePin, N as readNodePin, P as DATAPLANE_SECRET_HEADER, S as DeviceType, T as asJsonObject, a as viewerUiCapability, dt as BaseAddon, ft as normalizeAddonInitResult, ht as emitReadiness, i as deviceOpsCapability, m as expandCapMethods, o as adminUiCapability, s as createDeviceProxy, t as sleep, z as scopeKey } from "./sleep-BYyv9gUM.mjs";
+import { t as EventCategory } from "./event-category-Bz24uP1U.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/collection-array-methods.ts
 /**

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

@@ -634,8 +634,8 @@ export declare const addonsCapability: {
                 finishedAtMs: z.ZodNullable<z.ZodNumber>;
             }, z.core.$strip>>;
             state: z.ZodEnum<{
-                running: "running";
                 failed: "failed";
+                running: "running";
                 completed: "completed";
                 "partially-failed": "partially-failed";
                 cancelled: "cancelled";
@@ -710,8 +710,8 @@ export declare const addonsCapability: {
                 finishedAtMs: z.ZodNullable<z.ZodNumber>;
             }, z.core.$strip>>;
             state: z.ZodEnum<{
-                running: "running";
                 failed: "failed";
+                running: "running";
                 completed: "completed";
                 "partially-failed": "partially-failed";
                 cancelled: "cancelled";

package/dist/capabilities/device-manager.cap.d.ts

@@ -1672,6 +1672,28 @@ export declare const deviceManagerCapability: {
             deviceId: z.ZodNumber;
             caps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
         }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnknown>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * The same aggregate, for a LIST of devices in one round-trip.
+         *
+         * The viewer's camera list is the caller this exists for. Each card asked
+         * for its own badges — battery here, recording mode there — so a ten-camera
+         * install issued N separate procedures per reconcile, each its own message
+         * on the one WebSocket that also carries the WebRTC signalling (the client
+         * has no `httpBatchLink`, so there is no transport-level batching to lean
+         * on: collapsing has to happen at the procedure level, which is here).
+         *
+         * Keyed by device id as a STRING — a JSON object cannot key by number, and
+         * pretending otherwise is how a record survives the wire only in tests.
+         * The per-device value is exactly what `getDeviceStatusAggregate` returns,
+         * so a caller can move between the two without reshaping anything.
+         *
+         * `caps` matters more here than in the single call: a client that needs two
+         * caps should not pay for every status-carrying cap × every device.
+         */
+        readonly getDeviceStatusAggregateBatch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+            caps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnknown>>>, import("./capability-definition.js").CapabilityMethodKind>;
     };
 };
 export type IDeviceManagerProvider = import('./capability-definition.js').InferProvider<typeof deviceManagerCapability>;

package/dist/capabilities/index.d.ts

@@ -73,9 +73,9 @@ export { AddBrokerInputSchema, BrokerConnectionDetailsSchema, BrokerInfoSchema,
 export type { NetworkAccessStatus, NetworkEndpoint } from './network-access.cap.js';
 export { NetworkAccessStatusSchema, NetworkEndpointSchema, networkAccessCapability, } from './network-access.cap.js';
 export { type Attachment, type AttachmentMediaType, AttachmentMediaTypeSchema, AttachmentSchema, type DiscoveredTarget, DiscoveredTargetSchema, type INotificationOutputProvider, type NotificationAction, 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, type NcConditionDescriptor, NcConditionDescriptorSchema, type NcConditions, NcConditionsSchema, type NcDelivery, NcDeliverySchema, 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 NcRuleInput, NcRuleInputSchema, type NcRulePatch, NcRulePatchSchema, NcRuleSchema, type NcRuleTarget, NcRuleTargetSchema, type NcSchedule, NcScheduleSchema, type NcScheduleWindow, NcScheduleWindowSchema, type NcTestResult, NcTestResultSchema, type NcThrottle, NcThrottleSchema, type NcZoneCondition, NcZoneConditionSchema, notificationRulesCapability, } from './notification-rules.cap.js';
+export { type INotificationRulesProvider, NC_CONDITION_CATALOG, NC_HISTORY_LIMIT_DEFAULT, NC_HISTORY_LIMIT_MAX, NC_MAX_PER_TRACK_IMMEDIATE, type NcConditionDescriptor, NcConditionDescriptorSchema, type NcConditions, NcConditionsSchema, type NcCrossing, NcCrossingSchema, type NcDelivery, NcDeliverySchema, 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 NcRuleInput, NcRuleInputSchema, type NcRulePatch, NcRulePatchSchema, NcRuleSchema, type NcRuleTarget, NcRuleTargetSchema, type NcSchedule, NcScheduleSchema, type NcScheduleWindow, NcScheduleWindowSchema, 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 EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type MediaFile, 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, } 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 EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type MediaFile, 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 { 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';

package/dist/capabilities/llm-runtime.cap.d.ts

@@ -50,9 +50,9 @@ export type ManagedRuntimeConfig = z.infer<typeof ManagedRuntimeConfigSchema>;
 export declare const LlmRuntimeStatusSchema: z.ZodObject<{
     nodeId: z.ZodString;
     state: z.ZodEnum<{
-        ready: "ready";
         failed: "failed";
         stopped: "stopped";
+        ready: "ready";
         starting: "starting";
         downloading: "downloading";
         crashed: "crashed";
@@ -216,9 +216,9 @@ export declare const llmRuntimeCapability: {
         }, z.core.$strip>, z.ZodObject<{
             nodeId: z.ZodString;
             state: z.ZodEnum<{
-                ready: "ready";
                 failed: "failed";
                 stopped: "stopped";
+                ready: "ready";
                 starting: "starting";
                 downloading: "downloading";
                 crashed: "crashed";
@@ -237,9 +237,9 @@ export declare const llmRuntimeCapability: {
         readonly status: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
             nodeId: z.ZodString;
             state: z.ZodEnum<{
-                ready: "ready";
                 failed: "failed";
                 stopped: "stopped";
+                ready: "ready";
                 starting: "starting";
                 downloading: "downloading";
                 crashed: "crashed";

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

@@ -139,9 +139,9 @@ export declare const LlmRuntimeNodeSchema: z.ZodObject<{
     status: z.ZodOptional<z.ZodObject<{
         nodeId: z.ZodString;
         state: z.ZodEnum<{
-            ready: "ready";
             failed: "failed";
             stopped: "stopped";
+            ready: "ready";
             starting: "starting";
             downloading: "downloading";
             crashed: "crashed";
@@ -491,9 +491,9 @@ export declare const llmCapability: {
             status: z.ZodOptional<z.ZodObject<{
                 nodeId: z.ZodString;
                 state: z.ZodEnum<{
-                    ready: "ready";
                     failed: "failed";
                     stopped: "stopped";
+                    ready: "ready";
                     starting: "starting";
                     downloading: "downloading";
                     crashed: "crashed";
@@ -547,9 +547,9 @@ export declare const llmCapability: {
         }, z.core.$strip>, z.ZodObject<{
             nodeId: z.ZodString;
             state: z.ZodEnum<{
-                ready: "ready";
                 failed: "failed";
                 stopped: "stopped";
+                ready: "ready";
                 starting: "starting";
                 downloading: "downloading";
                 crashed: "crashed";
@@ -570,9 +570,9 @@ export declare const llmCapability: {
         }, z.core.$strip>, z.ZodObject<{
             nodeId: z.ZodString;
             state: z.ZodEnum<{
-                ready: "ready";
                 failed: "failed";
                 stopped: "stopped";
+                ready: "ready";
                 starting: "starting";
                 downloading: "downloading";
                 crashed: "crashed";

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
+import { type InferProvider } from './capability-definition.js';
 /**
  * Hardware / firmware motion sensor cap — binary detected state plus
  * a timestamp of the last observation. Distinct from
@@ -49,6 +49,18 @@ export declare const motionCapability: {
     readonly name: "motion";
     readonly scope: "device";
     readonly mode: "singleton";
+    /**
+     * Providers register per-device natives via `ctx.registerNativeCap`
+     * (Hikvision/Reolink/Amcrest/Wyze/HA/Homematic/Alexa/Matter) — there is
+     * NO system singleton provider. Without this flag `resolveCapMount`
+     * derived `{ kind: 'singleton' }`, so `motion.getStatus`/`isDetected`
+     * resolved via `registry.getSingleton('motion')` (always null) and every
+     * call 412'd "provider not available" while bindings listed a live
+     * `motion` native (2026-08-02). The flag routes the router through
+     * `requireDeviceScoped` → `getProviderForDevice`, like `motion-trigger`,
+     * `snapshot` and every other per-device native cap.
+     */
+    readonly deviceNative: true;
     readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor];
     readonly methods: {
         /**

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

@@ -108,6 +108,30 @@ export declare const NcOccupancyConditionSchema: z.ZodObject<{
     sustainSeconds: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type NcOccupancyCondition = z.infer<typeof NcOccupancyConditionSchema>;
+/**
+ * Which zone-crossing DIRECTION a rule accepts (`ObjectEvent.zoneCrossing`).
+ *
+ * The values are not symmetric, and deliberately so — the absent value has to
+ * mean exactly what every rule authored before this condition existed already
+ * does:
+ *  - `enter` — entries and every NON-crossing record (movement state,
+ *    package, sensor). Exits are rejected. **This is the absent behaviour**:
+ *    an operator who never asked for exits must not start receiving them.
+ *  - `exit`  — ONLY an exit crossing. A record that is not a crossing at all
+ *    fails closed, because "the car left the drive" is a question about a
+ *    boundary, not about a detection.
+ *  - `any`   — no direction filter; entries, exits and non-crossings alike.
+ *
+ * A rule asking for a direction should normally also scope `zones`, which the
+ * engine evaluates against the crossed zone as well as the current membership
+ * (an exit's membership no longer contains the zone it just left).
+ */
+export declare const NcCrossingSchema: z.ZodEnum<{
+    any: "any";
+    enter: "enter";
+    exit: "exit";
+}>;
+export type NcCrossing = z.infer<typeof NcCrossingSchema>;
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 export declare const NcZoneConditionSchema: z.ZodObject<{
     ids: z.ZodArray<z.ZodString>;
@@ -134,6 +158,11 @@ export declare const NcConditionsSchema: z.ZodObject<{
         }>>;
     }, z.core.$strip>>;
     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    crossing: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        enter: "enter";
+        exit: "exit";
+    }>>;
     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
     plates: z.ZodOptional<z.ZodObject<{
@@ -237,6 +266,23 @@ export declare const NcMediaPolicySchema: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 export type NcMediaPolicy = z.infer<typeof NcMediaPolicySchema>;
+/**
+ * Cooldown GRANULARITY over the subject's class — how much a fired
+ * notification suppresses.
+ *  - `shared` (default, and the absent value) — one window for the whole
+ *    rule/scope: a cat silences the next dog for `cooldownSec`.
+ *  - `per-class` — an independent window per detected class, so cat→dog fires
+ *    at once and cat→cat still waits.
+ *
+ * AUDIO subjects are ALWAYS per-class regardless of this setting: a scream
+ * must not be swallowed by a bark's window (the precedent this generalizes —
+ * see `cooldownKey` in the rule engine).
+ */
+export declare const NcThrottleGranularitySchema: z.ZodEnum<{
+    shared: "shared";
+    "per-class": "per-class";
+}>;
+export type NcThrottleGranularity = z.infer<typeof NcThrottleGranularitySchema>;
 /** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
 export declare const NcThrottleSchema: z.ZodObject<{
     cooldownSec: z.ZodDefault<z.ZodNumber>;
@@ -244,6 +290,10 @@ export declare const NcThrottleSchema: z.ZodObject<{
         rule: "rule";
         "rule-device": "rule-device";
     }>>;
+    granularity: z.ZodOptional<z.ZodEnum<{
+        shared: "shared";
+        "per-class": "per-class";
+    }>>;
 }, z.core.$strip>;
 export type NcThrottle = z.infer<typeof NcThrottleSchema>;
 /** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
@@ -269,6 +319,11 @@ export declare const NcRuleInputSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
         zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        crossing: z.ZodOptional<z.ZodEnum<{
+            any: "any";
+            enter: "enter";
+            exit: "exit";
+        }>>;
         labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
         identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
         plates: z.ZodOptional<z.ZodObject<{
@@ -355,6 +410,10 @@ export declare const NcRuleInputSchema: z.ZodObject<{
             rule: "rule";
             "rule-device": "rule-device";
         }>>;
+        granularity: z.ZodOptional<z.ZodEnum<{
+            shared: "shared";
+            "per-class": "per-class";
+        }>>;
     }, z.core.$strip>>;
     template: z.ZodOptional<z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
@@ -395,6 +454,11 @@ export declare const NcRulePatchSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
         zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        crossing: z.ZodOptional<z.ZodEnum<{
+            any: "any";
+            enter: "enter";
+            exit: "exit";
+        }>>;
         labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
         identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
         plates: z.ZodOptional<z.ZodObject<{
@@ -481,6 +545,10 @@ export declare const NcRulePatchSchema: z.ZodObject<{
             rule: "rule";
             "rule-device": "rule-device";
         }>>;
+        granularity: z.ZodOptional<z.ZodEnum<{
+            shared: "shared";
+            "per-class": "per-class";
+        }>>;
     }, z.core.$strip>>>;
     template: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
@@ -514,6 +582,11 @@ export declare const NcRuleSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
         zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        crossing: z.ZodOptional<z.ZodEnum<{
+            any: "any";
+            enter: "enter";
+            exit: "exit";
+        }>>;
         labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
         identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
         plates: z.ZodOptional<z.ZodObject<{
@@ -600,6 +673,10 @@ export declare const NcRuleSchema: z.ZodObject<{
             rule: "rule";
             "rule-device": "rule-device";
         }>>;
+        granularity: z.ZodOptional<z.ZodEnum<{
+            shared: "shared";
+            "per-class": "per-class";
+        }>>;
     }, z.core.$strip>>;
     template: z.ZodOptional<z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
@@ -656,6 +733,7 @@ export declare const NcConditionDescriptorSchema: z.ZodObject<{
         zoneSelection: "zoneSelection";
         zoneIdList: "zoneIdList";
         plateMatcher: "plateMatcher";
+        crossingSelect: "crossingSelect";
         polygonDraw: "polygonDraw";
     }>;
     operator: z.ZodEnum<{
@@ -816,6 +894,11 @@ export declare const notificationRulesCapability: {
                         }>>;
                     }, z.core.$strip>>;
                     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
                     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     plates: z.ZodOptional<z.ZodObject<{
@@ -902,6 +985,10 @@ export declare const notificationRulesCapability: {
                         rule: "rule";
                         "rule-device": "rule-device";
                     }>>;
+                    granularity: z.ZodOptional<z.ZodEnum<{
+                        shared: "shared";
+                        "per-class": "per-class";
+                    }>>;
                 }, z.core.$strip>>;
                 template: z.ZodOptional<z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
@@ -941,6 +1028,11 @@ export declare const notificationRulesCapability: {
                         }>>;
                     }, z.core.$strip>>;
                     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
                     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     plates: z.ZodOptional<z.ZodObject<{
@@ -1027,6 +1119,10 @@ export declare const notificationRulesCapability: {
                         rule: "rule";
                         "rule-device": "rule-device";
                     }>>;
+                    granularity: z.ZodOptional<z.ZodEnum<{
+                        shared: "shared";
+                        "per-class": "per-class";
+                    }>>;
                 }, z.core.$strip>>;
                 template: z.ZodOptional<z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
@@ -1064,6 +1160,11 @@ export declare const notificationRulesCapability: {
                         }>>;
                     }, z.core.$strip>>;
                     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
                     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     plates: z.ZodOptional<z.ZodObject<{
@@ -1150,6 +1251,10 @@ export declare const notificationRulesCapability: {
                         rule: "rule";
                         "rule-device": "rule-device";
                     }>>;
+                    granularity: z.ZodOptional<z.ZodEnum<{
+                        shared: "shared";
+                        "per-class": "per-class";
+                    }>>;
                 }, z.core.$strip>>;
                 template: z.ZodOptional<z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
@@ -1181,6 +1286,11 @@ export declare const notificationRulesCapability: {
                         }>>;
                     }, z.core.$strip>>;
                     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
                     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     plates: z.ZodOptional<z.ZodObject<{
@@ -1267,6 +1377,10 @@ export declare const notificationRulesCapability: {
                         rule: "rule";
                         "rule-device": "rule-device";
                     }>>;
+                    granularity: z.ZodOptional<z.ZodEnum<{
+                        shared: "shared";
+                        "per-class": "per-class";
+                    }>>;
                 }, z.core.$strip>>;
                 template: z.ZodOptional<z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
@@ -1307,6 +1421,11 @@ export declare const notificationRulesCapability: {
                         }>>;
                     }, z.core.$strip>>;
                     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
                     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     plates: z.ZodOptional<z.ZodObject<{
@@ -1393,6 +1512,10 @@ export declare const notificationRulesCapability: {
                         rule: "rule";
                         "rule-device": "rule-device";
                     }>>;
+                    granularity: z.ZodOptional<z.ZodEnum<{
+                        shared: "shared";
+                        "per-class": "per-class";
+                    }>>;
                 }, z.core.$strip>>>;
                 template: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
@@ -1425,6 +1548,11 @@ export declare const notificationRulesCapability: {
                         }>>;
                     }, z.core.$strip>>;
                     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
                     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     plates: z.ZodOptional<z.ZodObject<{
@@ -1511,6 +1639,10 @@ export declare const notificationRulesCapability: {
                         rule: "rule";
                         "rule-device": "rule-device";
                     }>>;
+                    granularity: z.ZodOptional<z.ZodEnum<{
+                        shared: "shared";
+                        "per-class": "per-class";
+                    }>>;
                 }, z.core.$strip>>;
                 template: z.ZodOptional<z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
@@ -1566,6 +1698,11 @@ export declare const notificationRulesCapability: {
                         }>>;
                     }, z.core.$strip>>;
                     zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
                     labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     plates: z.ZodOptional<z.ZodObject<{
@@ -1652,6 +1789,10 @@ export declare const notificationRulesCapability: {
                         rule: "rule";
                         "rule-device": "rule-device";
                     }>>;
+                    granularity: z.ZodOptional<z.ZodEnum<{
+                        shared: "shared";
+                        "per-class": "per-class";
+                    }>>;
                 }, z.core.$strip>>;
                 template: z.ZodOptional<z.ZodObject<{
                     title: z.ZodOptional<z.ZodString>;
@@ -1715,6 +1856,7 @@ export declare const notificationRulesCapability: {
                     zoneSelection: "zoneSelection";
                     zoneIdList: "zoneIdList";
                     plateMatcher: "plateMatcher";
+                    crossingSelect: "crossingSelect";
                     polygonDraw: "polygonDraw";
                 }>;
                 operator: z.ZodEnum<{

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

@@ -296,6 +296,43 @@ export declare const DetectionSourceSchema: z.ZodEnum<{
     onboard: "onboard";
 }>;
 export type DetectionSource = z.infer<typeof DetectionSourceSchema>;
+/**
+ * Which WAY a subject crossed a zone boundary. An entry and an exit are two
+ * different notifications ("the parcel arrived" / "the car left the drive"),
+ * and until this existed they were indistinguishable on the persisted record —
+ * which is why exits were computed and dropped at the emit boundary rather
+ * than doubling every zone-scoped rule.
+ */
+export declare const ZoneCrossingDirectionSchema: z.ZodEnum<{
+    enter: "enter";
+    exit: "exit";
+}>;
+export type ZoneCrossingDirection = z.infer<typeof ZoneCrossingDirectionSchema>;
+/**
+ * The confirmed zone crossing that produced an object event. Present ONLY on
+ * an event emitted BY a crossing (`zone.enter` / `zone.exit`); a movement-state
+ * event (`object.entering` / `leaving` / `stationary` / `loitering`) and an
+ * appearance event carry none, so a rule asking for a direction fails closed
+ * on them.
+ *
+ * Exactly ONE crossing per event: the emitter turns each confirmed crossing
+ * into its own event, so a frame in which a track enters A while leaving B
+ * produces two events with two directions — never one ambiguous row.
+ *
+ * `zoneId` is load-bearing for an EXIT: the event's `zones` list is the
+ * membership the box has NOW, and by definition it no longer contains the zone
+ * that was just left. Without the id here, a zone-scoped rule could never match
+ * the exit it asked for.
+ */
+export declare const ZoneCrossingSchema: z.ZodObject<{
+    direction: z.ZodEnum<{
+        enter: "enter";
+        exit: "exit";
+    }>;
+    zoneId: z.ZodString;
+    zoneName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ZoneCrossing = z.infer<typeof ZoneCrossingSchema>;
 declare const ObjectEventSchema: z.ZodObject<{
     kind: z.ZodLiteral<"object">;
     source: z.ZodOptional<z.ZodEnum<{
@@ -321,6 +358,14 @@ declare const ObjectEventSchema: z.ZodObject<{
         new: "new";
         entered: "entered";
     }>>;
+    zoneCrossing: z.ZodOptional<z.ZodObject<{
+        direction: z.ZodEnum<{
+            enter: "enter";
+            exit: "exit";
+        }>;
+        zoneId: z.ZodString;
+        zoneName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     frameWidth: z.ZodOptional<z.ZodNumber>;
     frameHeight: z.ZodOptional<z.ZodNumber>;
     mediaKey: z.ZodOptional<z.ZodString>;
@@ -520,6 +565,14 @@ export declare const ScoredObjectEventSchema: z.ZodObject<{
         new: "new";
         entered: "entered";
     }>>;
+    zoneCrossing: z.ZodOptional<z.ZodObject<{
+        direction: z.ZodEnum<{
+            enter: "enter";
+            exit: "exit";
+        }>;
+        zoneId: z.ZodString;
+        zoneName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     frameWidth: z.ZodOptional<z.ZodNumber>;
     frameHeight: z.ZodOptional<z.ZodNumber>;
     mediaKey: z.ZodOptional<z.ZodString>;
@@ -959,6 +1012,14 @@ export declare const pipelineAnalyticsCapability: {
                 new: "new";
                 entered: "entered";
             }>>;
+            zoneCrossing: z.ZodOptional<z.ZodObject<{
+                direction: z.ZodEnum<{
+                    enter: "enter";
+                    exit: "exit";
+                }>;
+                zoneId: z.ZodString;
+                zoneName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
             frameWidth: z.ZodOptional<z.ZodNumber>;
             frameHeight: z.ZodOptional<z.ZodNumber>;
             mediaKey: z.ZodOptional<z.ZodString>;
@@ -1235,9 +1296,9 @@ export declare const pipelineAnalyticsCapability: {
         readonly getMediaRelocateStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             jobId: z.ZodString;
             state: z.ZodEnum<{
-                running: "running";
                 done: "done";
                 failed: "failed";
+                running: "running";
                 cancelled: "cancelled";
             }>;
             fromLocationId: z.ZodString;
@@ -1403,6 +1464,14 @@ export declare const pipelineAnalyticsCapability: {
                 new: "new";
                 entered: "entered";
             }>>;
+            zoneCrossing: z.ZodOptional<z.ZodObject<{
+                direction: z.ZodEnum<{
+                    enter: "enter";
+                    exit: "exit";
+                }>;
+                zoneId: z.ZodString;
+                zoneName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
             frameWidth: z.ZodOptional<z.ZodNumber>;
             frameHeight: z.ZodOptional<z.ZodNumber>;
             mediaKey: z.ZodOptional<z.ZodString>;

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

@@ -381,9 +381,9 @@ declare const EngineProvisioningSchema: z.ZodObject<{
     }>>;
     device: z.ZodNullable<z.ZodString>;
     state: z.ZodEnum<{
-        ready: "ready";
         failed: "failed";
         idle: "idle";
+        ready: "ready";
         installing: "installing";
         verifying: "verifying";
     }>;
@@ -530,9 +530,9 @@ export declare const pipelineExecutorCapability: {
             }>>;
             device: z.ZodNullable<z.ZodString>;
             state: z.ZodEnum<{
-                ready: "ready";
                 failed: "failed";
                 idle: "idle";
+                ready: "ready";
                 installing: "installing";
                 verifying: "verifying";
             }>;