@camstack/addon-post-analysis 1.2.211 → 1.2.213

package/dist/{dist-D2rFaMex.mjs → dist-CT2SouNJ.mjs}

@@ -7823,6 +7823,226 @@ var CameraSwitchGroupSchema = object({
 */
 var DETECTION_PIPELINE_CAP_NAME = "detection-pipeline";
 /**
+* Birth-decision ledger — one durable row per track-birth VERDICT (D409).
+*
+* ── Why this exists ────────────────────────────────────────────────────────
+* On 2026-09-08 the operator marked eleven tracks for review and five of them
+* said "traccia partita in ritardo" — the track appears to begin long after the
+* subject entered the scene. Two causes were proposed and NEITHER was measured:
+*
+*  - the confirmation gate's deferral (`maxDeferralMs`, 2 s). This is now
+*    DISPROVEN as a cause of a late TIMELINE: a track's `firstSeen` and its
+*    first position are the CANDIDATE's first frame, not the confirmation's.
+*    Verified on `d035f251` (device 3829): first position == `firstSeen`, with
+*    confirmation 2 163 ms later.
+*  - the detector simply not firing until the subject is well into the scene.
+*    Unmeasured, and the reason this table exists.
+*
+* A second, real defect is also unquantified. The deferred-birth re-offer in
+* `index.ts` takes the track from `result.tracked` with NO `matchedThisFrame`
+* check, so a birth can be CONFIRMED on a frame the subject was never observed
+* in. D379's carried birth evidence means some of those confirmations rest on a
+* real observation of the birth instant anyway — and how often is exactly what
+* nobody knows. {@link BirthDecisionRecord.decidedOnCoastedFrame} and
+* {@link BirthDecisionRecord.decidedByBirthEvidence} are the two columns that
+* answer it together.
+*
+* ── Why a TABLE and not a log line ─────────────────────────────────────────
+* `logs.query` is an in-memory ring. Measured on the live hub on 2026-09-08 it
+* held 40 000 entries covering 38 minutes — the whole ring is under an hour of
+* fleet traffic. Every question this data is for ("how often, on camera 617,
+* over the week the operator complained about") outlives that ring by two
+* orders of magnitude, and a previous investigation in this repo was blocked
+* for precisely this reason. The gate ALREADY writes a log line per decision
+* (`confirmation gate: birth confirmed/suppressed/undecided`); adding a
+* fourteenth field to it would answer nothing a day later.
+*
+* This is a MEASUREMENT table. It changes no behaviour, gates nothing, and
+* nothing reads it on the frame path.
+*/
+/**
+* How many birth decisions the cluster keeps, across every camera.
+*
+* Sized off a MEASURED rate, not a guess. Fleet-wide on the live hub,
+* 2026-09-08 20:16 local, over the 38 minutes the log ring covered: 17 `track
+* started` + 14 `birth suppressed — track record retracted` = 31 decided
+* births, i.e. ~49/hour, ~1 200/day. Call a busy daytime hour five times that
+* and the fleet writes ~6 000 rows/day.
+*
+* 30 000 rows is therefore ~25 days at the measured rate and ~5 days at five
+* times it — comfortably past "a few days of traffic", which is the bar the
+* operator's week-long complaint sets. At ~200 bytes a row the ceiling is
+* ~6 MB, against a `tracks` table measured at 4.6 MB for a single 501-row page.
+*
+* A COUNT and not an age, for the same reason as the debug-note archive: the
+* denominator of a miss rate is only meaningful over whatever window the table
+* actually holds, and a quiet fleet should keep more of it, not less. Trimmed
+* oldest-first on append.
+*/
+var MAX_BIRTH_DECISION_RECORDS = 3e4;
+/**
+* How stale a motion onset may be and still be offered as the birth-latency
+* proxy. Beyond this the row records `null`, never a large number.
+*
+* 60 s is one order of magnitude above the latency being measured (the
+* complaint is "seconds late") and one below the duration of a busy scene's
+* continuous motion burst, where the onset is minutes old and says nothing
+* about THIS subject. See {@link BirthDecisionRecord.birthLatencyMs} for the
+* full error bars.
+*/
+var MAX_BIRTH_LATENCY_PROXY_MS = 6e4;
+/**
+* What the gate decided about a birth, from the CALLER's point of view.
+*
+* Deliberately not `ConfirmationVerdict`: `undecided` is not a birth decision
+* at all — it is a deferral, and the row is written when the deferral ENDS.
+* The third member is the one the gate's own type cannot express, because
+* exhaustion is a property of how long the caller waited.
+*/
+var BirthDecisionVerdictSchema = _enum([
+	"confirmed",
+	"suppressed",
+	"exhausted-fallback"
+]);
+/** One birth decision, as it is kept. */
+var BirthDecisionRecordSchema = object({
+	id: string(),
+	/** Epoch ms the VERDICT was taken (not the birth instant — see `firstSeen`). */
+	at: number().int(),
+	/** The camera. Required: every question here is asked per-camera. */
+	deviceId: number().int(),
+	/**
+	* The track the decision was about. PROVENANCE, not ownership — a suppressed
+	* birth has no track at all, and a confirmed one is expected to age out long
+	* before this row does. Named `sourceTrackId` so the retention model's
+	* ownership derivation (`collection-classification.ts`, which keys on a
+	* column literally called `trackId`) cannot reach it.
+	*/
+	sourceTrackId: string(),
+	/** The candidate's claimed class. The miss rate is asked per class too. */
+	className: string(),
+	verdict: BirthDecisionVerdictSchema,
+	/**
+	* The gate's own `ConfirmationReason` (`confirmed`, `suppressed`,
+	* `native-pass`, `no-crop`, `timeout`, `carried-inconclusive`, …), or `null`
+	* when the gate is DISABLED and every birth is waved through. `null` is not
+	* "unknown": it says the gate took no measurement because it was off, which
+	* is a different population and must never be averaged in with the rest.
+	*/
+	reason: string().nullable(),
+	/** Deferral attempts this birth used. 0 = decided on its first look. */
+	attempts: number().int(),
+	/** Ms from the FIRST undecided attempt to this verdict. 0 = never deferred. */
+	deferredForMs: number().int(),
+	/**
+	* THE COLUMN THE RE-OFFER DEFECT IS COUNTED IN.
+	*
+	* `true` when the frame the verdict was taken on carried no matched
+	* detection for this track — the tracker was coasting a frozen box and the
+	* subject was not observed. The deferred-birth re-offer pulls the candidate
+	* straight out of `result.tracked` without checking, so this is reachable
+	* today; the question is the RATE, per camera, and whether refusing those
+	* frames would have cost real tracks (cross-read against `verdict` and
+	* `decidedByBirthEvidence`).
+	*/
+	decidedOnCoastedFrame: boolean(),
+	/** Were D379 birth-instant pixels in hand when this candidate was submitted? */
+	birthEvidenceAvailable: boolean(),
+	/**
+	* Did those pixels DECIDE it (`cropSource === 'carried'`)? Available and
+	* deciding are different: the carried crop is confirm-only, so a candidate
+	* can hold evidence, be found inconclusive on it, and be decided by a native
+	* crop of a later instant. A coasted decision backed by carried evidence is
+	* a real observation of the birth instant; one without it is not.
+	*/
+	decidedByBirthEvidence: boolean(),
+	/** Best class-compatible crop score, or `null` when nothing compatible was
+	*  found — deliberately not 0, which would be a measurement that never was. */
+	bestScore: number().nullable(),
+	/** The bar this candidate actually faced (the phantom-cell hook may raise it). */
+	appliedMinConfidence: number().nullable(),
+	/**
+	* The track's own `firstSeen` — the candidate's first frame, which is where
+	* the timeline starts. `null` for a suppressed birth, which has no track.
+	*/
+	firstSeen: number().int().nullable(),
+	/**
+	* The device's most recent motion RISING EDGE at the moment of the decision,
+	* or `null` when there is none, it is older than
+	* {@link MAX_BIRTH_LATENCY_PROXY_MS}, or this runner never saw one.
+	*/
+	motionOnsetAt: number().int().nullable(),
+	/**
+	* `firstSeen − motionOnsetAt` — THE OPERATOR'S COMPLAINT, IN MILLISECONDS,
+	* AND THE WEAKEST NUMBER IN THIS ROW. Read the error bars before quoting it.
+	*
+	* **Why motion onset and not something else.** Two other proxies were
+	* considered and rejected:
+	*  - *the recording/pipeline session start*: for a camera on
+	*    `detectionMode: 'always'` the session opens at process start, hours
+	*    before any subject. It measures nothing.
+	*  - *the first detection on the device in this burst*: CIRCULAR. A track's
+	*    `firstSeen` IS the first detection of that object, so for the track that
+	*    OPENS a burst — the only one the operator is complaining about — the two
+	*    are the same instant and the latency is 0 by construction.
+	* Motion onset is the only in-process signal produced by a DIFFERENT
+	* mechanism from the object detector, so it is the only one that can precede
+	* it. It is also already maintained per-device at frame rate on this very
+	* node (`handleMotionAnalysis` / `handleOnboardMotion`), which is what makes
+	* it free — and, decisively, the frame path and the motion path are gated to
+	* the SAME designated post-processing node, so the mirror is never empty for
+	* a camera whose births land here.
+	*
+	* **Error bars, all of them.**
+	*  1. *Motion has no class.* A burst opened by rain, a headlight sweeping a
+	*     wall or a branch, and only later joined by the person, OVERSTATES the
+	*     latency without bound. Mitigated, never removed, by
+	*     {@link BirthDecisionRecord.birthIndexInBurst}: only index 0 is a
+	*     candidate for "this burst is this subject", and even then it is a
+	*     candidate, not a fact.
+	*  2. *The sign is not guaranteed.* The analyzer needs a pixel-count and
+	*     intensity threshold. A subject entering slowly at the far edge of the
+	*     frame can clear the detector's confidence floor BEFORE it clears the
+	*     motion floor, making this negative. Negatives are stored as-is and
+	*     never clamped — clamping would fabricate the distribution's left tail,
+	*     which is the half that says the proxy is unreliable.
+	*  3. *Onboard motion carries firmware latency of unknown, per-model offset*
+	*     (hundreds of ms), plus camera-vs-hub clock skew on top. Numbers are
+	*     therefore comparable WITHIN a camera and not across cameras of
+	*     different motion sources. The motion source is deliberately not copied
+	*     here — it belongs to the addon that owns the device (D224) and this is
+	*     a write on the frame path — so group by `deviceId`, which is how the
+	*     question is always asked anyway.
+	*  4. *Continuous motion.* On a busy scene the burst never closes and the
+	*     onset is minutes old. Bounded by {@link MAX_BIRTH_LATENCY_PROXY_MS};
+	*     past it this is `null`.
+	*  5. *No motion signal at all* — analyzer off, onboard-only camera not
+	*     reporting, or nothing since boot: `null`. Which is the truth about a
+	*     camera nobody has a reference instant for.
+	*
+	* So this is a per-camera DISTRIBUTION over index-0 births, and it is honest
+	* as such. It is not a per-track fact and must never be shown as one.
+	*/
+	birthLatencyMs: number().int().nullable(),
+	/**
+	* How many births this device has already decided since that motion onset.
+	* 0 = the first, i.e. the only index at which the burst plausibly belongs to
+	* this subject. `null` when there is no usable onset.
+	*/
+	birthIndexInBurst: number().int().nullable()
+});
+/** Query input for `listBirthDecisions` — newest first, one camera or all. */
+var BirthDecisionQueryInputSchema = object({
+	/** Restrict to a single camera; omit for every row. */
+	deviceId: number().int().optional(),
+	/** Only decisions at or after this epoch ms. */
+	since: number().int().optional(),
+	/** Restrict to one verdict — the miss rate is read one population at a time. */
+	verdict: BirthDecisionVerdictSchema.optional(),
+	/** Max rows returned, newest-first. */
+	limit: number().int().min(1).max(5e3).optional()
+});
+/**
 * Debug-note archive — the durable corpus of what operators asked to be
 * checked, and the ONE thing about a debug note that outlives its track.
 *
@@ -21462,6 +21682,26 @@ var pipelineAnalyticsCapability = {
 		*/
 		listArchivedDebugNotes: method(ArchivedDebugNoteQueryInputSchema, array(ArchivedDebugNoteSchema).readonly(), { kind: "query" }),
 		/**
+		* Birth decisions — one row per resolved confirmation-gate verdict (D409).
+		*
+		* The READ half of a measurement, and only that: it gates nothing and no
+		* runtime path consults it. It exists because the two questions the
+		* operator's "traccia partita in ritardo" marks raised are both multi-day
+		* and `logs.query` holds under an hour of fleet traffic —
+		*   • how often is a birth DECIDED on a frame the subject was not observed
+		*     in (`decidedOnCoastedFrame`), and did D379's carried pixels make it a
+		*     real observation anyway (`decidedByBirthEvidence`);
+		*   • how long after the camera's motion onset does a track's `firstSeen`
+		*     land (`birthLatencyMs` — read its error bars in
+		*     `BirthDecisionRecordSchema` before quoting it).
+		*
+		* Newest-first, capped by `limit` (default
+		* {@link BIRTH_DECISION_DEFAULT_LIMIT}), optionally scoped to one camera,
+		* one verdict, or a `since`. The table is bounded by row count, not age —
+		* see {@link MAX_BIRTH_DECISION_RECORDS}.
+		*/
+		listBirthDecisions: method(BirthDecisionQueryInputSchema, array(BirthDecisionRecordSchema).readonly(), { kind: "query" }),
+		/**
 		* Durable event-store footprint for the management UI: event rows
 		* (motion + object + audio) counted per camera + total, plus the
 		* event-owned media bytes on disk per camera + total. Stat/count-based,
@@ -22243,6 +22483,22 @@ var occupancyRecheckFramesField = {
 	step: 1
 };
 /**
+* Frames one PRE-ROLL catch-up burst may send to inference at session open.
+*
+* The default of 12 over a ~4 s retained window is one frame per ~333 ms of
+* footage, and costs ~480 ms of ONE inference permit at the 40 ms/frame this
+* fleet measures — one-shot, and only ever taken while a permit would still be
+* spare for live. `0` turns the burst off entirely (the history is still
+* decoded, because that is how the dial reaches a decodable GOP, and is then
+* discarded — the pre-D411 behaviour).
+*/
+var preRollInferenceFramesField = {
+	min: 0,
+	max: 30,
+	default: 12,
+	step: 1
+};
+/**
 * Source enum for motion signals fed to the runner. Extensible — add
 * new variants here when new motion-trigger paths are wired in
 * (`wasm-cross-camera`, `event-bus-relay`, etc.). The runner uses
@@ -22483,6 +22739,31 @@ var RunnerCameraConfigSchema = object({
 	* to every occupancy rule until something moved in front of it. The churn is
 	* now paid on the interval instead — see `occupancyRecheckSecField`.
 	*/
+	/**
+	* Infer the session's PRE-ROLL — the retained history the restreamer replays
+	* at session open — instead of decoding it and throwing it away.
+	*
+	* DEFAULT `true`, and the default is the argument. This is not a new
+	* capability being offered cautiously: the pre-roll is ALREADY requested,
+	* already served, already decoded and already paid for on every on-motion
+	* detection session that asks for history. What shipped was a last-moment
+	* discard — `FrameSlot`'s throttle compares wall clocks, and ~4 s of media
+	* arriving inside a few hundred ms of wall clock looks to it like one frame's
+	* worth. Device 617, 2026-09-08: a re-run of the SAME model over the stored
+	* recording scored the subject `vehicle 0.5669` — above the 0.50 floor —
+	* 1.68 s BEFORE the live track was born, on a frame that was in the pre-roll,
+	* was decoded, and was freed.
+	*
+	* Shipping that as opt-in would ship the bug: an operator cannot discover a
+	* setting whose absence looks exactly like a camera that noticed the cyclist
+	* late. What makes ON safe is not a switch but the BOUND —
+	* `preRollInferenceFrames`, a wall-clock ceiling, and a lane that never takes
+	* the last inference permit — so the switch exists for the camera where the
+	* history is worthless (a doorbell whose subject is always already at the
+	* door), not as a hedge against the feature.
+	*/
+	preRollInferenceEnabled: boolean().default(true),
+	preRollInferenceFrames: number().min(preRollInferenceFramesField.min).max(preRollInferenceFramesField.max).default(preRollInferenceFramesField.default),
 	occupancyRecheckEnabled: boolean().default(true),
 	occupancyRecheckSec: number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
@@ -22511,7 +22792,7 @@ var RunnerCameraConfigSchema = object({
 	*/
 	inferenceDevices: array(RunnerInferenceDeviceSchema).readonly().optional()
 });
-motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, maxSessionHoldMsField.min, maxSessionHoldMsField.max, maxSessionHoldMsField.step, maxSessionHoldMsField.default, audioMotionWindowMsField.min, audioMotionWindowMsField.max, audioMotionWindowMsField.step, audioMotionWindowMsField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
+motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, maxSessionHoldMsField.min, maxSessionHoldMsField.max, maxSessionHoldMsField.step, maxSessionHoldMsField.default, audioMotionWindowMsField.min, audioMotionWindowMsField.max, audioMotionWindowMsField.step, audioMotionWindowMsField.default, preRollInferenceFramesField.min, preRollInferenceFramesField.max, preRollInferenceFramesField.step, preRollInferenceFramesField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
 /**
 * Runtime load summary returned by `getLocalLoad`. Used by the orchestrator's
 * load-balancing levels (L2 capacity-based, L3 hardware-aware) to decide
@@ -39139,6 +39420,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listBirthDecisions": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listEventKinds": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -42931,6 +43218,11 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"pipelineAnalytics.listBirthDecisions": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"pipelineAnalytics.listEventKinds": [{
 		name: "deviceId",
 		form: "single",
@@ -44857,4 +45149,4 @@ function vectorDimFromBase64(encoded) {
 	return Math.floor(Buffer.from(encoded, "base64").byteLength / 4);
 }
 //#endregion
-export { assertTimelapseCadences as $, string as $t, NcScheduleSchema as A, subKindsOf as At, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS as B, hydrateSchema as Bt, NC_SNOOZE_MAX_MINUTES as C, plateGalleryCapability as Ct, NcRulePatchSchema as D, resolvePoolMemoryPolicy as Dt, NcRuleInputSchema as E, resolveLocationMode as Et, NcTaxonomySchema as F, errMsg as Ft, TIMELAPSE_DENSE_FLOOR_SEC as G, array as Gt, SCENE_DEFAULT_UNCOVERED_POLICY as H, nodePin as Ht, OpsLogEntrySchema as I, BaseAddon as It, TimelapseRuleSchema as J, literal as Jt, TimelapseRuleInputSchema as K, boolean as Kt, PoolMemoryWatchdog as L, CamProfileSchema as Lt, NcSnoozeSchema as M, vectorDimFromBase64 as Mt, NcSnoozeSuppressedSchema as N, videoclipsCapability as Nt, NcRuleSchema as O, sceneMonitorCapability as Ot, NcSystemEventKindSchema as P, zoneAnalyticsCapability as Pt, alarmPanelCapability as Q, record as Qt, RECORDING_EXPORT_MAX_READ_BYTES as R, DeviceType as Rt, NC_DEFAULT_SNOOZE_MINUTES as S, pipelineAnalyticsCapability as St, NcConditionDescriptorSchema as T, readTimelapseGeneratedAt as Tt, SCENE_DIVERGED as U, sleep as Ut, SCENE_DEFAULT_ANCHOR_THRESHOLD as V, isDeviceScopedCap as Vt, SceneMonitorSchema as W, _enum as Wt, VISIT_MERGE_GAP_MS as X, object as Xt, TrackSourceSchema as Y, number as Yt, addonWidgetsSourceCapability as Z, partialRecord as Zt, MACRO_LABELS as _, kebabToCamel as _t, COCO_TO_MACRO as a, defineCustomActions as at, NC_ALARM_SYSTEM_EVENT_KINDS as b, parseProcStatus as bt, DEFAULT_TIMELAPSE_PREVIEW_TEXT as c, encodeVectorBase64 as ct, DeclaredDevices as d, faceGalleryCapability as dt, unknown as en, audioMetricsCapability as et, EVENT_KIND_BY_CAP as f, failureContributionCapability as ft, LabelAttributionSchema as g, isSourceCap as gt, FailureCounters as h, isScheduleActive as ht, CLUSTER_MODEL_SCOPED_STEPS as i, customAction as it, NcSnoozeInputSchema as j, systemEventFilterApplies as jt, NcRuleTargetSchema as k, storageOccupancyCapability as kt, DETECTION_MACRO_CLASSES as l, evaluateSensorEdge as lt, FULL_IMAGE_BBOX as m, isDetectionMacroClass as mt, ArchivedDebugNoteSchema as n, buildEventKindDescriptor as nt, DEFAULT_EVENT_COLOR as o, deriveRecordingMode as ot, EVENT_PAD_MS as p, hfModelUrl as pt, TimelapseRulePatchSchema as q, discriminatedUnion as qt, BaseDevice as r, cosineSimilarity as rt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as s, embeddingEncoderCapability as st, AUDIO_MACRO_LABELS as t, EventCategory as tn, audioModeOf as tt, DETECTION_PIPELINE_CAP_NAME as u, evictionPolicyOfLocation as ut, MAX_ARCHIVED_DEBUG_NOTES as v, mayWriteToLocation as vt, NC_TAXONOMY as w, readDeviceStateFrom as wt, NC_CONDITION_CATALOG as x, pickClusterStepModels as xt, MediaFileKindEnum as y, notificationRulesCapability as yt, RetrainStatusSchema as z, createEvent as zt };
+export { VISIT_MERGE_GAP_MS as $, object as $t, NcRulePatchSchema as A, resolvePoolMemoryPolicy as At, PoolMemoryWatchdog as B, CamProfileSchema as Bt, NC_ALARM_SYSTEM_EVENT_KINDS as C, parseProcStatus as Ct, NC_TAXONOMY as D, readDeviceStateFrom as Dt, NC_SNOOZE_MAX_MINUTES as E, plateGalleryCapability as Et, NcSnoozeSchema as F, vectorDimFromBase64 as Ft, SCENE_DEFAULT_UNCOVERED_POLICY as G, nodePin as Gt, RetrainStatusSchema as H, createEvent as Ht, NcSnoozeSuppressedSchema as I, videoclipsCapability as It, TIMELAPSE_DENSE_FLOOR_SEC as J, array as Jt, SCENE_DIVERGED as K, sleep as Kt, NcSystemEventKindSchema as L, zoneAnalyticsCapability as Lt, NcRuleTargetSchema as M, storageOccupancyCapability as Mt, NcScheduleSchema as N, subKindsOf as Nt, NcConditionDescriptorSchema as O, readTimelapseGeneratedAt as Ot, NcSnoozeInputSchema as P, systemEventFilterApplies as Pt, TrackSourceSchema as Q, number as Qt, NcTaxonomySchema as R, errMsg as Rt, MediaFileKindEnum as S, notificationRulesCapability as St, NC_DEFAULT_SNOOZE_MINUTES as T, pipelineAnalyticsCapability as Tt, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS as U, hydrateSchema as Ut, RECORDING_EXPORT_MAX_READ_BYTES as V, DeviceType as Vt, SCENE_DEFAULT_ANCHOR_THRESHOLD as W, isDeviceScopedCap as Wt, TimelapseRulePatchSchema as X, discriminatedUnion as Xt, TimelapseRuleInputSchema as Y, boolean as Yt, TimelapseRuleSchema as Z, literal as Zt, LabelAttributionSchema as _, isDetectionMacroClass as _t, CLUSTER_MODEL_SCOPED_STEPS as a, buildEventKindDescriptor as at, MAX_BIRTH_DECISION_RECORDS as b, kebabToCamel as bt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as c, defineCustomActions as ct, DETECTION_PIPELINE_CAP_NAME as d, encodeVectorBase64 as dt, partialRecord as en, addonWidgetsSourceCapability as et, DeclaredDevices as f, evaluateSensorEdge as ft, FailureCounters as g, hfModelUrl as gt, FULL_IMAGE_BBOX as h, failureContributionCapability as ht, BirthDecisionRecordSchema as i, EventCategory as in, audioModeOf as it, NcRuleSchema as j, sceneMonitorCapability as jt, NcRuleInputSchema as k, resolveLocationMode as kt, DEFAULT_TIMELAPSE_PREVIEW_TEXT as l, deriveRecordingMode as lt, EVENT_PAD_MS as m, faceGalleryCapability as mt, ArchivedDebugNoteSchema as n, string as nn, assertTimelapseCadences as nt, COCO_TO_MACRO as o, cosineSimilarity as ot, EVENT_KIND_BY_CAP as p, evictionPolicyOfLocation as pt, SceneMonitorSchema as q, _enum as qt, BaseDevice as r, unknown as rn, audioMetricsCapability as rt, DEFAULT_EVENT_COLOR as s, customAction as st, AUDIO_MACRO_LABELS as t, record as tn, alarmPanelCapability as tt, DETECTION_MACRO_CLASSES as u, embeddingEncoderCapability as ut, MACRO_LABELS as v, isScheduleActive as vt, NC_CONDITION_CATALOG as w, pickClusterStepModels as wt, MAX_BIRTH_LATENCY_PROXY_MS as x, mayWriteToLocation as xt, MAX_ARCHIVED_DEBUG_NOTES as y, isSourceCap as yt, OpsLogEntrySchema as z, BaseAddon as zt };