@camstack/system 1.2.214 → 1.2.217

package/dist/{dist-9GQQ9F3s.js → dist-C85OOASj.js}

@@ -1,5 +1,5 @@
 let zod = require("zod");
-//#region ../types/dist/event-category-CnLqLOKs.mjs
+//#region ../types/dist/event-category-DAXzJeTX.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -591,7 +591,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	* issue. Payload `PipelineAnalyticsPlateGalleryChangedPayload`.
 	*/
 	EventCategory["PipelineAnalyticsPlateGalleryChanged"] = "pipeline-analytics.plate-gallery-changed";
-	EventCategory["FrigateLiveEvent"] = "frigate.live-event";
 	EventCategory["CameraStreamsProfileSlotsChanged"] = "camera-streams.onProfileSlotsChanged";
 	/**
 	* Stream-broker health watchdog. Per-broker (deviceId/profile) emission.
@@ -10421,7 +10420,7 @@ var detectionPipelineCapability = {
 var SourceInfoSchema = zod.z.object({
 	/** Live dispatch key — mutable when the source system allows rename. */
 	id: zod.z.string(),
-	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'frigate'. */
+	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'onvif'. */
 	system: zod.z.string(),
 	/** Immutable upstream identifier when available (HA `unique_id`, … ).
 	*  Used to detect rename when `id` changes. */
@@ -11123,7 +11122,7 @@ var deviceProviderCapability = {
 *   - `device-management.router.ts` (deleted in Phase 2)
 *   - `device-ops.router.ts` (compat layer — deleted; device-provider ops absorbed here)
 *
-* All device provider addons (rtsp, onvif, frigate, …) are hub-local: they may
+* All device provider addons (rtsp, onvif, …) are hub-local: they may
 * fork into separate processes but never run on remote cluster agents. Therefore:
 *   - No nodeId routing needed — this is a pure hub singleton.
 *   - The hub's DeviceRegistry is the single source of truth for all live devices.
@@ -16069,7 +16068,7 @@ var NcRuleInputSchema = zod.z.object({
 	* The measured seven-person arrival on device 590 spans 110 s with every
 	* internal gap under 30 s. A 12 s fixed window cuts it into three groups; an
 	* idle cutoff holds it as one and ends it when the arrival actually ends.
-	* 30 is Frigate's shipped value for the same decision.
+	* 30 s is a widely shipped value for the same decision.
 	*
 	* ### What it replaces
 	*
@@ -18476,6 +18475,13 @@ var ZoneCrossingSchema = zod.z.object({
 	/** Zone display name at crossing time (falls back to the id). */
 	zoneName: zod.z.string().optional()
 });
+/** One zone a box was stamped with, and how much of the BOX fell inside it. */
+var ZoneOverlapSchema = zod.z.object({
+	zoneId: zod.z.string(),
+	zoneName: zod.z.string().optional(),
+	/** Percentage of the BOX area inside the zone, 0–100. */
+	overlapPct: zod.z.number()
+});
 var ObjectEventSchema = zod.z.object({
 	...BaseEventFields,
 	kind: zod.z.literal("object"),
@@ -18500,6 +18506,35 @@ var ObjectEventSchema = zod.z.object({
 	bbox: BoundingBoxSchema.optional(),
 	/** Heavy JSON — omitted in slim projection. */
 	zones: zod.z.array(zod.z.string()).readonly().optional(),
+	/**
+	* How far inside each stamped zone the box actually was, as a percentage of
+	* the BOX area.
+	*
+	* Membership alone cannot express "at least a third of it inside", which is
+	* the bar an operator argues with — and the number already existed: the
+	* engine computed it, the pipeline logged it, and then discarded it. It
+	* matters most on the events that carry no track, where a rule has nothing
+	* else to judge by.
+	*/
+	zoneOverlaps: zod.z.array(ZoneOverlapSchema).readonly().optional(),
+	/**
+	* Present when this event describes a detection the TRACKER refused, so it
+	* has no track and never will.
+	*
+	* A zone-scoped immediate rule asks "is there an animal in the flowerbed
+	* NOW?"; tracking answers a different question ("is this the same subject as
+	* before?") whose confirmation threshold presumes continuity. On 2026-09-09 a
+	* dog at 0.7729, 100% inside a watched zone, was refused three times in six
+	* seconds with three different candidate ids — seven analysed frames in the
+	* window, the subject in a handful of them, metres apart — and produced no
+	* event at all.
+	*
+	* It is NAMED rather than merely implied by a missing `trackId`: an event
+	* with no track and no reason is indistinguishable from a track whose media
+	* went missing, and a consumer that asks this one for a best shot or a
+	* history is asking for something that never existed.
+	*/
+	spawnRefused: zod.z.string().optional(),
 	/** Omitted in slim projection. */
 	state: TrackStateSchema.optional(),
 	/**
@@ -18926,7 +18961,17 @@ var EventDensityBucketSchema = zod.z.object({
 	bucketStart: zod.z.number(),
 	motion: zod.z.number().int(),
 	object: zod.z.number().int(),
-	audio: zod.z.number().int()
+	audio: zod.z.number().int(),
+	/**
+	* Energy-weighted mean dBFS of the audio events in this bucket — the LEVEL,
+	* as opposed to `audio`, which is their COUNT (D431).
+	*
+	* ABSENT when the bucket holds no audio event. Absence means "nothing was
+	* measured", which is not the same claim as silence, and a lane that cannot
+	* tell them apart paints a quiet hour at full scale — which is exactly what
+	* the count-on-a-level-meter did.
+	*/
+	audioDbfs: zod.z.number().optional()
 });
 /**
 * One camera's row in a `getEventDensityBatch` answer.
@@ -20169,6 +20214,60 @@ var NativeCropResultSchema = zod.z.object({
 	*/
 	tier: zod.z.enum(["native", "ram-fullframe"]).optional()
 });
+/**
+* What a PARKED frame is for — the `kind` half of the `(deviceId, trackId,
+* kind)` key ([D422](../../../docs/decisions/adr-0422-a-relevant-frame-is-parked-when-it-becomes-relevant.md)).
+*
+* - `keyFrame` — the track's clean best FULL frame at native width (capped by
+*   the caller's `maxWidth`). What `keyFrame` + `keyFrameSmall` are written
+*   from, and what the detail plane's full-frame rung cuts from.
+* - `thumbnail` — the best-shot subject slab: the caller's 16:9 central-square
+*   window, cut by the runner at uncapped native resolution.
+*
+* The runner never interprets `trackId`; it is an opaque key the hub owns.
+*/
+var ParkedFrameKindSchema = zod.z.enum(["keyFrame", "thumbnail"]);
+/**
+* Why a park did NOT happen. Every one is logged on the runner with
+* `tags: { deviceId }` and the handle's measured age, because a handle already
+* gone at park time IS the defect the 150–500 ms window exists to prevent —
+* never a reason to retry in a loop.
+*
+* - `handle-gone` — the native surface no longer resolves this handle (never
+*   registered, past the lease bound, or the worker released it). `detail`
+*   carries the runner's own miss reason.
+* - `encode-failed` — pixels resolved and the JPEG encode threw.
+*/
+var ParkRefusalSchema = zod.z.enum(["handle-gone", "encode-failed"]);
+/** Answer to `parkTrackFrame` — a discriminated union, so "not parked" always names why. */
+var ParkTrackFrameResultSchema = zod.z.discriminatedUnion("parked", [zod.z.object({
+	parked: zod.z.literal(true),
+	/** The node holding the parcel — what a later retrieval must be pinned to. */
+	nodeId: zod.z.string(),
+	width: zod.z.number().int().positive(),
+	height: zod.z.number().int().positive(),
+	/** JPEG bytes the parcel costs on the node. */
+	bytes: zod.z.number().int().nonnegative(),
+	/** Whether this park replaced a parcel already held for the key. */
+	replaced: zod.z.boolean()
+}), zod.z.object({
+	parked: zod.z.literal(false),
+	nodeId: zod.z.string(),
+	reason: ParkRefusalSchema,
+	/** Age of the handle at the park, on the runner's clock; null if unknown. */
+	handleAgeMs: zod.z.number().nullable(),
+	detail: zod.z.string().optional()
+})]);
+/** A retrieved parcel — the runner's own JPEG, base64 for the wire. */
+var ParkedTrackFrameSchema = zod.z.object({
+	jpeg: zod.z.string(),
+	width: zod.z.number().int().positive(),
+	height: zod.z.number().int().positive(),
+	/** The frame instant the parcel shows (the caller's clock, echoed back). */
+	timestamp: zod.z.number(),
+	/** When the node stored it (the node's clock). */
+	parkedAt: zod.z.number()
+});
 /** Parent detection context passed to `runDetailSubtree` — the crop's
 *  originating detection, in FRAME-space coordinates. Reuses
 *  `NativeCropBboxSchema`'s `{x,y,w,h}` shape (same numeric fields; here
@@ -20558,7 +20657,7 @@ var RunnerCameraConfigSchema = zod.z.object({
 	* - `analyzer`: ML/frame-diff motion detection (motion-wasm or other
 	*   analyzer providers) running on decoded frames in this runner.
 	* - `onboard`: camera-native motion pushes (Reolink Baichuan, ONVIF
-	*   analytics, Frigate motion). The provider emits ProviderMotion
+	*   analytics). The provider emits ProviderMotion
 	*   events; the orchestrator forwards to `reportMotion`.
 	*/
 	motionSources: MotionSourcesSchema.default(["analyzer"]),
@@ -20940,7 +21039,60 @@ var pipelineRunnerCapability = {
 			className: zod.z.string(),
 			/** Camera the pixels came from. Diagnostics + log tags ONLY — never routing. */
 			sourceDeviceId: zod.z.number()
-		}), RunStatelessStepResultSchema, { kind: "mutation" })
+		}), RunStatelessStepResultSchema, { kind: "mutation" }),
+		/**
+		* PARK a frame for a track at the instant it is judged to matter
+		* ([D422](../../../docs/decisions/adr-0422-a-relevant-frame-is-parked-when-it-becomes-relevant.md)).
+		*
+		* The hub's `BestDetectionTracker` — the single "best per track" policy —
+		* concludes a frame is a track's best and calls this on the node that
+		* owns `handle` (`nodePin(handle.nodeId)`), while the handle is young. The
+		* runner cuts `bbox` from the native surface it already holds (a full
+		* frame for `keyFrame`, the caller's subject window for `thumbnail`),
+		* encodes ONE JPEG, and keeps it under `(deviceId, trackId, kind)`. Every
+		* later consumer retrieves by that key (`getParkedTrackFrame`) — a lookup
+		* that cannot miss on age. D52 holds: the rectangle is cut by the runner,
+		* never a pre-cut tile the caller decided. D9/D18 hold: one compressed
+		* encode at a decision point, never a stream.
+		*
+		* Idempotent per `(trackId, kind)`: a later park replaces (the ranking is
+		* the hub's; this adds no second opinion), an out-of-order older instant
+		* is ignored. Bounded per device and per node on the runner
+		* (`parked-frame-store.ts`), oldest-first eviction, never a refusal for
+		* space. A refusal names its reason and is logged on the runner with the
+		* handle's measured age — it is never retried into a loop.
+		*/
+		parkTrackFrame: method(zod.z.object({
+			deviceId: zod.z.number(),
+			/** Opaque to the runner — the hub's track id. */
+			trackId: zod.z.string(),
+			kind: ParkedFrameKindSchema,
+			handle: FrameHandleSchema,
+			/** Normalized [0,1] window to cut. `{0,0,1,1}` for a full frame. */
+			bbox: NativeCropBboxSchema,
+			/** Width cap for a full-frame park (the `keyFrame` native cap). */
+			maxWidth: zod.z.number().int().positive().optional(),
+			/** The frame instant (caller's clock) — orders parks for one key. */
+			timestamp: zod.z.number()
+		}), ParkTrackFrameResultSchema, { kind: "mutation" }),
+		/**
+		* Retrieve a parked parcel by `(deviceId, trackId, kind)`. Pinned to the
+		* node that answered the park (`ParkTrackFrameResult.nodeId`). `null` means
+		* nothing was parked under that key on this node — never "too old".
+		*/
+		getParkedTrackFrame: method(zod.z.object({
+			deviceId: zod.z.number(),
+			trackId: zod.z.string(),
+			kind: ParkedFrameKindSchema
+		}), ParkedTrackFrameSchema.nullable()),
+		/**
+		* Drop every parcel of a track — the hub closed it. Idempotent. A track
+		* whose release is lost ages out on the runner under a hard ceiling.
+		*/
+		releaseParkedTrackFrames: method(zod.z.object({
+			deviceId: zod.z.number(),
+			trackId: zod.z.string()
+		}), zod.z.object({ released: zod.z.number().int().nonnegative() }), { kind: "mutation" })
 	}
 };
 var CameraPipelineConfigSchema = zod.z.object({
@@ -25243,8 +25395,8 @@ onStatusChanged: { data: zod.z.object({
 	/**
 	* Runtime-state slice — every provider that registers this cap
 	* stores the same shape under `device.runtimeState[battery]`.
-	* Cross-provider uniformity: a Reolink Argus, a Frigate sensor
-	* proxy, an ONVIF battery cam all read/write the same keys.
+	* Cross-provider uniformity: a Reolink Argus, a sensor proxy,
+	* an ONVIF battery cam all read/write the same keys.
 	* Consumers (BatteryBadge, snapshot wrapper sleep gate) read once
 	* via `device.runtimeState.getCapState('battery')` regardless of
 	* the underlying driver.
@@ -25394,7 +25546,7 @@ var buttonCapability = {
 *
 * Implementations:
 *   - Each camera-providing addon registers this cap natively per
-*     device (Reolink, Hikvision, RTSP, Frigate, ONVIF self).
+*     device (Reolink, Hikvision, RTSP, ONVIF self).
 *   - Returns a snapshot from the persisted device config blob — no
 *     extra round-trip to the camera, no probing.
 *   - The cap is admin-only (`auth: 'admin'`) — credentials must not
@@ -27613,7 +27765,7 @@ var AvailableIntegrationTypeSchema = zod.z.object({
 	* Which integration-marker cap the addon declared, so the wizard can
 	* branch on CAP — never on addon name. `device-adoption` integrations
 	* (Home Assistant, …) route through the broker step (Approach A);
-	* `device-provider` integrations (Reolink/Frigate/ONVIF) keep the
+	* `device-provider` integrations (Reolink/ONVIF) keep the
 	* legacy config → discovery flow.
 	*/
 	kind: zod.z.enum(["device-adoption", "device-provider"]),
@@ -31494,7 +31646,23 @@ var RecordingRangeSchema = zod.z.object({
 });
 var RecordingAvailabilitySchema = zod.z.object({
 	deviceId: zod.z.number(),
-	ranges: zod.z.array(RecordingRangeSchema)
+	ranges: zod.z.array(RecordingRangeSchema),
+	/**
+	* Every profile this camera has footage in — not only the one `ranges`
+	* describes (D433).
+	*
+	* `ranges` answers for ONE profile by design: the timeline is a single bar,
+	* and enumerating all of them triples the directory reads for a bar that
+	* would look identical. But the answer used to say nothing about that, so a
+	* caller asking "what can I export?" read the single preferred profile as
+	* the only one that exists — on this deployment every camera records `high`
+	* AND `low`, the low tree holding 14 GB for camera 615 alone, and the export
+	* UI could not see it.
+	*
+	* Cheap: it is the same shallow directory read the profile CHOICE already
+	* makes. Ask for a specific profile's ranges with the `profile` input.
+	*/
+	profilesWithFootage: zod.z.array(zod.z.string())
 });
 var RecordingDaysSchema = zod.z.object({
 	deviceId: zod.z.number(),
@@ -31520,7 +31688,11 @@ var RecordingDaysSchema = zod.z.object({
 var RecordingAvailabilityForDeviceSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	read: zod.z.enum(["read", "unreadable"]),
-	ranges: zod.z.array(RecordingRangeSchema).readonly()
+	ranges: zod.z.array(RecordingRangeSchema).readonly(),
+	/** Same field, same meaning, as the singular answer (D433). A row that
+	*  dropped it would tell a grid caller the archive holds one profile.
+	*  Empty on an `'unreadable'` row: nobody looked. */
+	profilesWithFootage: zod.z.array(zod.z.string()).readonly()
 });
 /**
 * One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
@@ -31550,13 +31722,31 @@ var RecordingManifestSchema = zod.z.object({
 	*/
 	playbackEndpoints: zod.z.array(zod.z.string())
 });
-/** Recording storage usage for one camera (bytes on disk across all its
-*  profiles/subtrees/locations on this node). */
+/**
+* Recording storage usage for one camera — what the ARCHIVE holds for it,
+* across every profile and every resolvable location on this node.
+*
+* ## Archive vs residency, which is the whole point of this shape (D418)
+*
+* `usedBytes` / `oldestMs` / `segments` are the durable hour ledger's numbers:
+* the same quantity `RecordingLocationUsage.usedBytes` reports for the volume
+* this camera writes to, so the two can be added up and compared.
+*
+* They were not always. Until D418 this row came from the recorder's in-RAM
+* `RecordingIndex`, which since D287 holds only the live tail plus the hours
+* somebody hydrated — so a hub with 1.9 TB and 3.3 days of footage reported
+* 60.5 GB and "oldest: three hours ago" on the same page as the volume row
+* that said otherwise, and two people read it as retention eating recent
+* footage. Residency is still reported, under `residentBytes` /
+* `residentOldestMs`, which answer a different question and say so.
+*/
 var RecordingDeviceUsageSchema = zod.z.object({
 	deviceId: zod.z.number(),
+	/** Bytes the ARCHIVE holds for this camera on this node's resolvable
+	*  recordings locations. */
 	usedBytes: zod.z.number(),
 	/**
-	* Start of this camera's OLDEST indexed segment, across every profile and
+	* Start of this camera's OLDEST ARCHIVED segment, across every profile and
 	* location — the "Oldest footage" column in Recordings → Storage, and the
 	* only honest answer to "is retention actually holding?" per camera.
 	*
@@ -31566,7 +31756,24 @@ var RecordingDeviceUsageSchema = zod.z.object({
 	* (types) and the addon ship on different trains, and the addon is usually
 	* the later of the two.
 	*/
-	oldestMs: zod.z.number().nullable().optional()
+	oldestMs: zod.z.number().nullable().optional(),
+	/** Segments the archive holds for this camera — the "M" beside `usedBytes`.
+	*  OPTIONAL for the same train-skew reason as `oldestMs`. */
+	segments: zod.z.number().optional(),
+	/**
+	* RESIDENCY, not the archive: bytes the recorder process currently holds in
+	* its RAM index — the live tail plus the hours a reader hydrated.
+	*
+	* It answers "what can be served without touching the disk", never "how much
+	* footage this camera has". A UI that renders it must label it as such, and
+	* must never total it as storage. OPTIONAL: a recorder predating D418 omits
+	* it, and so does a node whose ledger could not answer.
+	*/
+	residentBytes: zod.z.number().optional(),
+	/** The residency counterpart of `oldestMs` — the oldest segment currently in
+	*  RAM, which on a healthy recorder is minutes ago and means nothing about
+	*  retention. `null` = nothing resident. */
+	residentOldestMs: zod.z.number().nullable().optional()
 });
 /** Recording storage usage + capacity for one storage location. */
 var RecordingLocationUsageSchema = zod.z.object({
@@ -31604,6 +31811,17 @@ var RecordingStorageUsageSchema = zod.z.object({
 	totalUsedBytes: zod.z.number(),
 	devices: zod.z.array(RecordingDeviceUsageSchema),
 	/**
+	* WHERE `devices[]` came from, so an empty table is never mistaken for empty
+	* disks (D418).
+	*
+	* `archive` = the durable hour ledger answered. `unavailable` = this node
+	* declared no ledger and the recorder REFUSED rather than answering the
+	* question with the resident index (D295 rule 3) — the rows are UNKNOWN, not
+	* zero, and a UI must say so. OPTIONAL: a recorder predating D418 omits it,
+	* and its rows are residency.
+	*/
+	devicesRead: zod.z.enum(["archive", "unavailable"]).optional(),
+	/**
 	* Per-physical-volume capacity. OPTIONAL, and consumers must render the rest
 	* of the payload without it: the hub serves this method through a BAKED
 	* router, so a hub whose framework train predates a change to this array
@@ -31774,7 +31992,14 @@ var recordingCapability = {
 		getAvailability: method(zod.z.object({
 			deviceId: zod.z.number(),
 			fromMs: zod.z.number(),
-			toMs: zod.z.number()
+			toMs: zod.z.number(),
+			/**
+			* Answer for THIS profile instead of the preferred one (D433). Absent
+			* keeps the timeline's behaviour — one bar, one profile, one set of
+			* reads. `profilesWithFootage` on the answer says what may be asked
+			* for.
+			*/
+			profile: zod.z.string().optional()
 		}), RecordingAvailabilitySchema, {
 			kind: "query",
 			auth: "protected"
@@ -40206,6 +40431,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineRunner.getParkedTrackFrame": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineRunner.parkTrackFrame": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineRunner.releaseParkedTrackFrames": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineRunner.reportMotion": {
 		capName: "pipeline-runner",
 		capScope: "system",
@@ -43483,6 +43726,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineRunner.getParkedTrackFrame": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.parkTrackFrame": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pipelineRunner.releaseParkedTrackFrames": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineRunner.reportMotion": [{
 		name: "deviceId",
 		form: "single",
@@ -44466,7 +44724,7 @@ var PreviewTextField = zod.z.string().max(200);
 * Whether the notification's preview is a STILL or a short animation.
 *
 * The operator's ask, verbatim: *"inviato come gif o video (come per le altre
-* rule)"* — his Scrypted advanced-notifier has a `gifRule`, and a ten-hour
+* rule)"* — the other rules already offer an animated preview, and a ten-hour
 * night reads better as three seconds of motion than as one frame of it. Both
 * modes get the SAME treatment (blurred frame, large centred title); `'gif'`
 * simply applies it to a dozen frames sampled across the render and assembles