@camstack/addon-post-analysis 1.2.214 → 1.2.217

package/dist/{dist-DA1sJKXM.js → dist-B_6UZCut.js}

@@ -29,7 +29,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#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";
@@ -621,7 +621,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.
@@ -13249,7 +13248,7 @@ DeviceType.Camera;
 var SourceInfoSchema = object({
 	/** Live dispatch key — mutable when the source system allows rename. */
 	id: string(),
-	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'frigate'. */
+	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'onvif'. */
 	system: string(),
 	/** Immutable upstream identifier when available (HA `unique_id`, … ).
 	*  Used to detect rename when `id` changes. */
@@ -13262,7 +13261,7 @@ var SourceInfoSchema = object({
 /**
 * Build the synthetic SourceInfo every existing provider falls back to
 * when no upstream value has been persisted. Keeps non-migrated providers
-* (Reolink / Hikvision / ONVIF / Frigate / RTSP) functional without code
+* (Reolink / Hikvision / ONVIF / RTSP) functional without code
 * changes — `id` reuses the CamStack stableId, `system` reuses the addon
 * id. Real upstream identity replaces this once a provider migrates and
 * calls `updateSourceInfo()` with concrete values.
@@ -13843,7 +13842,7 @@ method(_void(), _void(), { kind: "mutation" }), method(_void(), _void(), { kind:
 *   - `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.
@@ -17995,7 +17994,7 @@ var NcRuleInputSchema = 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
 	*
@@ -20637,6 +20636,13 @@ var ZoneCrossingSchema = object({
 	/** Zone display name at crossing time (falls back to the id). */
 	zoneName: string().optional()
 });
+/** One zone a box was stamped with, and how much of the BOX fell inside it. */
+var ZoneOverlapSchema = object({
+	zoneId: string(),
+	zoneName: string().optional(),
+	/** Percentage of the BOX area inside the zone, 0–100. */
+	overlapPct: number()
+});
 var ObjectEventSchema = object({
 	...BaseEventFields,
 	kind: literal("object"),
@@ -20661,6 +20667,35 @@ var ObjectEventSchema = object({
 	bbox: BoundingBoxSchema.optional(),
 	/** Heavy JSON — omitted in slim projection. */
 	zones: array(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: 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: string().optional(),
 	/** Omitted in slim projection. */
 	state: TrackStateSchema.optional(),
 	/**
@@ -22329,6 +22364,60 @@ var NativeCropResultSchema = object({
 	*/
 	tier: _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 = _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 = _enum(["handle-gone", "encode-failed"]);
+/** Answer to `parkTrackFrame` — a discriminated union, so "not parked" always names why. */
+var ParkTrackFrameResultSchema = discriminatedUnion("parked", [object({
+	parked: literal(true),
+	/** The node holding the parcel — what a later retrieval must be pinned to. */
+	nodeId: string(),
+	width: number().int().positive(),
+	height: number().int().positive(),
+	/** JPEG bytes the parcel costs on the node. */
+	bytes: number().int().nonnegative(),
+	/** Whether this park replaced a parcel already held for the key. */
+	replaced: boolean()
+}), object({
+	parked: literal(false),
+	nodeId: string(),
+	reason: ParkRefusalSchema,
+	/** Age of the handle at the park, on the runner's clock; null if unknown. */
+	handleAgeMs: number().nullable(),
+	detail: string().optional()
+})]);
+/** A retrieved parcel — the runner's own JPEG, base64 for the wire. */
+var ParkedTrackFrameSchema = object({
+	jpeg: string(),
+	width: number().int().positive(),
+	height: number().int().positive(),
+	/** The frame instant the parcel shows (the caller's clock, echoed back). */
+	timestamp: number(),
+	/** When the node stored it (the node's clock). */
+	parkedAt: 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
@@ -22718,7 +22807,7 @@ var RunnerCameraConfigSchema = 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"]),
@@ -22960,7 +23049,26 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
 	className: string(),
 	/** Camera the pixels came from. Diagnostics + log tags ONLY — never routing. */
 	sourceDeviceId: number()
-}), RunStatelessStepResultSchema, { kind: "mutation" });
+}), RunStatelessStepResultSchema, { kind: "mutation" }), method(object({
+	deviceId: number(),
+	/** Opaque to the runner — the hub's track id. */
+	trackId: 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: number().int().positive().optional(),
+	/** The frame instant (caller's clock) — orders parks for one key. */
+	timestamp: number()
+}), ParkTrackFrameResultSchema, { kind: "mutation" }), method(object({
+	deviceId: number(),
+	trackId: string(),
+	kind: ParkedFrameKindSchema
+}), ParkedTrackFrameSchema.nullable()), method(object({
+	deviceId: number(),
+	trackId: string()
+}), object({ released: number().int().nonnegative() }), { kind: "mutation" });
 var CameraPipelineConfigSchema = object({
 	engine: PipelineEngineChoiceSchema.optional(),
 	steps: array(PipelineStepInputSchema).readonly(),
@@ -26094,8 +26202,8 @@ onStatusChanged: { data: 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.
@@ -26228,7 +26336,7 @@ DeviceType.Button, method(object({ deviceId: number().int().nonnegative() }), _v
 *
 * 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
@@ -28359,7 +28467,7 @@ var AvailableIntegrationTypeSchema = 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: _enum(["device-adoption", "device-provider"]),
@@ -31817,13 +31925,31 @@ var RecordingManifestSchema = object({
 	*/
 	playbackEndpoints: array(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 = object({
 	deviceId: number(),
+	/** Bytes the ARCHIVE holds for this camera on this node's resolvable
+	*  recordings locations. */
 	usedBytes: 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.
 	*
@@ -31833,7 +31959,24 @@ var RecordingDeviceUsageSchema = object({
 	* (types) and the addon ship on different trains, and the addon is usually
 	* the later of the two.
 	*/
-	oldestMs: number().nullable().optional()
+	oldestMs: number().nullable().optional(),
+	/** Segments the archive holds for this camera — the "M" beside `usedBytes`.
+	*  OPTIONAL for the same train-skew reason as `oldestMs`. */
+	segments: 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: 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: number().nullable().optional()
 });
 /** Recording storage usage + capacity for one storage location. */
 var RecordingLocationUsageSchema = object({
@@ -31871,6 +32014,17 @@ var RecordingStorageUsageSchema = object({
 	totalUsedBytes: number(),
 	devices: 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: _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
@@ -40207,6 +40361,24 @@ 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",
@@ -43484,6 +43656,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",
@@ -44276,7 +44463,7 @@ var PreviewTextField = 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