@camstack/types 1.2.70 → 1.2.72

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_category = require("./event-category-DxZbWydC.js");
-const require_sleep = require("./sleep-YuacOD41.js");
+const require_event_category = require("./event-category-D3gG7oil.js");
+const require_sleep = require("./sleep-CKWYtvXl.js");
 const require_canonical_hash = require("./canonical-hash-DNV8S5ET.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -11958,6 +11958,8 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"stream-offline",
 	"node-online",
 	"node-offline",
+	"node-inference-unavailable",
+	"detection-blind",
 	"addon-update-available",
 	"server-update-available",
 	"alarm-triggered",
@@ -12802,7 +12804,50 @@ var NcRuleInputSchema = zod.z.object({
 	* tests every zone the track visited and a `crossing` condition can no longer
 	* be satisfied, because a closed track carries no crossing.
 	*/
-	waitForEnhancement: zod.z.boolean().optional()
+	waitForEnhancement: zod.z.boolean().optional(),
+	/**
+	* GROUP a burst of subjects into ONE notification that grows.
+	*
+	* Seconds of quiet after the last matching subject before the burst is
+	* considered over. While it is open, the first subject enqueues immediately —
+	* **exactly as today, with no added latency** — and every real growth (a new
+	* subject, or a name confirmed on one already in it) REPLACES that
+	* notification with an updated one naming everybody. The push carries the
+	* group's own coalescing tag, so the phone replaces rather than stacks.
+	*
+	* `0` / absent = off, and off is today's behaviour byte for byte.
+	*
+	* ### Why an idle cutoff and not a window
+	*
+	* 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.
+	*
+	* ### What it replaces
+	*
+	* The blind cooldown, which collapses a burst by DISCARDING it. Measured on
+	* device 615 / *Persona su Uscio* over six days: 116 qualifying tracks → 74
+	* notifications, **44 (37.9%) suppressed outright**, 23 of them overlapping a
+	* track that did fire and 7 carrying a confirmed identity nobody heard about.
+	* A group collapses the same volume by MERGING, so the cooldown becomes a
+	* budget over GROUPS — which is what it always meant — and a growth is never
+	* throttled by the window its own first member spent.
+	*
+	* ### Interaction with {@link waitForEnhancement}
+	*
+	* They compose, and the order matters. `waitForEnhancement` defers the rule to
+	* TRACK CLOSE, so with both set the group is opened by the first member to
+	* CLOSE — already carrying its name — and grows as later members close. That
+	* is later, and complete. With grouping alone the group opens on the first
+	* object event and picks up names as they are confirmed, through the growth
+	* path. Neither combination fires twice for one subject.
+	*
+	* `.optional()` and deliberately NOT `.default()`: a Zod default does not run
+	* on the addon cap path, so absent must keep meaning what it meant before this
+	* field existed.
+	*/
+	groupIdleSec: zod.z.number().int().min(0).max(600).optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -12989,6 +13034,14 @@ var NC_CONDITION_CATALOG = [
 				value: "node-offline",
 				label: "Node offline"
 			},
+			{
+				value: "node-inference-unavailable",
+				label: "Node has no usable inference device"
+			},
+			{
+				value: "detection-blind",
+				label: "Camera detecting nothing"
+			},
 			{
 				value: "addon-update-available",
 				label: "Addon update available"
@@ -14250,7 +14303,7 @@ var TrackEnvelopeSchema = zod.z.object({
 * `snapshots[]` references — megabytes across a page of tracks. `slim`
 * keeps every scalar the list surfaces actually render (ids, class(es),
 * label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
-* zonesVisited, bestEventId, envelope, hasFace) and returns `positions` /
+* zonesVisited, bestEventId, envelope, hasFace, hasRider) and returns `positions` /
 * `snapshots` as EMPTY arrays — detail views re-fetch the full row via
 * `getTrack`. Mirrors the event-store `projection` convention
 * (`getObjectEvents` et al.).
@@ -14553,6 +14606,28 @@ var TrackSchema = zod.z.object({
 	* `=== true` and render nothing otherwise, never infer "no face".
 	*/
 	hasFace: zod.z.boolean().optional(),
+	/**
+	* This subject CONTAINS a folded rider — a person the rider-pairing step
+	* ([D34](../decisions/adr-0034.md)) removed from the frame BEFORE the tracker,
+	* so the passage is tracked once and as a VEHICLE.
+	*
+	* It exists because the fold's record was dishonest. D34 and the code both
+	* said "the person is not lost — it is reported so both entities stay on the
+	* record"; in fact the pair went into a per-processor RAM field behind an
+	* accessor nobody called, and every durable surface said `vehicle`, full
+	* stop. This is the composition note that makes the row true.
+	*
+	* A COMPOSITION, never a class and never a label. "This vehicle contains a
+	* person" is not an answer to "what is this" — both label tiers would refuse
+	* a macro token anyway (D89), and correctly. Nothing here changes what the
+	* subject IS: a cyclist stays one vehicle track, occupancy still counts one,
+	* and a `person` rule still does not fire for someone cycling past.
+	*
+	* **Absent ≠ false**, exactly like {@link hasFace}: every row written before
+	* the column, and every hub that predates the field, omits it. Test
+	* `=== true` and render nothing otherwise — never infer "no rider".
+	*/
+	hasRider: zod.z.boolean().optional(),
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
@@ -27303,9 +27378,47 @@ var recordingExportCapability = {
 * settings-contribution methods. `status.kind:'push'` — the engine pushes on
 * every hysteresis flip / availability change; consumers never poll.
 */
-/** Extensible condition tag. Seeded 'day' | 'night'; open by design so more can
-*  be added without a wire break (matching falls back to any-condition refs). */
+/** Extensible condition tag. Seeded 'day' | 'ir' (the two variants the operator
+*  captures) plus 'night' | 'dawn' | 'dusk' from the resolver's sun-times band.
+*  Open by design so more can be added without a wire break.
+*
+*  Matching does NOT fall back across conditions: cross-condition cosines are
+*  not comparable, so "I have never seen this scene in this light" is reported
+*  as `unknown`, never guessed. A day reference scored against an IR frame
+*  collapses the cosine and would latch a false alarm every single night. */
 var SceneConditionSchema = zod.z.string();
+/** The conditions the resolver can produce. Seeds for the UI's coverage line;
+*  the wire type stays an open string. */
+var SCENE_CONDITIONS = [
+	"day",
+	"ir",
+	"night",
+	"dawn",
+	"dusk"
+];
+/** Reserved, engine-owned state id standing for "the region no longer looks
+*  like ANY captured reference". Never authored by an operator, never stored in
+*  `states[]` — it is the synthetic candidate that makes divergence a
+*  first-class hysteresis input rather than a bare `return`. */
+var SCENE_DIVERGED = "__diverged__";
+/** `matched` = the baseline is what we see; `diverged` = it demonstrably is not;
+*  `unknown` = we cannot judge (no reference for this condition, encoder model
+*  changed, view shifted, no snapshot). `unknown` is a real value, not a null,
+*  and never counts toward hysteresis in either direction. */
+var SceneVerdictSchema = zod.z.enum([
+	"matched",
+	"diverged",
+	"unknown"
+]);
+/** Why a scene cannot judge. Named, because this feature's failure mode is
+*  silence that reads as "nothing has happened". */
+var SceneUnavailableSchema = zod.z.enum([
+	"no-reference-for-condition",
+	"view-shifted",
+	"no-vision-profile",
+	"encoder-model-changed",
+	"no-snapshot"
+]);
 /** One captured reference — condition-tagged, model-version-gated. `embedding`
 *  is `number[]` (Float32Array does NOT survive MsgPack/UDS). */
 var SceneReferenceSchema = zod.z.object({
@@ -27313,7 +27426,14 @@ var SceneReferenceSchema = zod.z.object({
 	modelId: zod.z.string(),
 	condition: SceneConditionSchema,
 	capturedAt: zod.z.number(),
-	thumbnailMediaId: zod.z.string().optional()
+	thumbnailMediaId: zod.z.string().optional(),
+	/** Whole-frame (downscaled) embedding captured alongside the ROI crop. The
+	*  anti-view-shift anchor: a bumped camera, a PTZ preset or a re-aim makes the
+	*  normalized rect frame a different piece of world, and the scene would
+	*  diverge forever with a perfectly plausible cosine. Checked LAZILY, only
+	*  when hysteresis is about to flip — one extra encode per candidate
+	*  transition, not per poll. */
+	anchorEmbedding: zod.z.array(zod.z.number()).optional()
 });
 var SceneMonitorStateSchema = zod.z.object({
 	id: zod.z.string(),
@@ -27335,6 +27455,38 @@ var SceneCheckSchema = zod.z.discriminatedUnion("mode", [zod.z.object({
 	profileId: zod.z.string().optional(),
 	hysteresisCount: zod.z.number().int().positive()
 })]);
+/** Defaults, as CONSTANTS rather than only as Zod `.default()`. A Zod default
+*  does NOT run on the addon→addon cap path, so every runtime seam reads these
+*  as absent-with-a-constant (the `NcConfirmSchema` lesson, three production
+*  failures in one day). The schema defaults and these values are the same
+*  numbers on purpose. */
+var SCENE_DEFAULT_QUIET_SECONDS = 60;
+var SCENE_DEFAULT_OBSERVATION_SPACING_SEC = 120;
+var SCENE_DEFAULT_CHECK_INTERVAL_SEC = 60;
+var SCENE_DEFAULT_ANCHOR_THRESHOLD = .85;
+var SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = 8e3;
+var SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = 448;
+/** `resetScene({ recapture })` absent means TRUE — the operator decision. Read
+*  at the seam, because a Zod `.optional()` carries no default at all. */
+var SCENE_RESET_RECAPTURES = true;
+/**
+* Vision-model adjudication of a candidate flip. Field names deliberately
+* mirror `NcConfirmSchema` so an operator meets one vocabulary, not two.
+*
+* `onTimeout` defaults to **'hold'**, the OPPOSITE of `NcConfirmGate`'s
+* fail-open: a notification suppressed is the worse error there, but a vision
+* model that timed out has not told us the bin is gone, and a latch is a
+* stateful claim that costs the operator a trip to reset.
+*/
+var SceneConfirmSchema = zod.z.object({
+	enabled: zod.z.boolean().default(false),
+	prompt: zod.z.string().min(1).max(1e3),
+	profileId: zod.z.string().optional(),
+	timeoutMs: zod.z.number().int().min(1e3).max(2e4).default(SCENE_CONFIRM_DEFAULT_TIMEOUT_MS),
+	maxImagePx: zod.z.number().int().min(64).max(2048).default(448),
+	/** What a timeout / unavailable model means for the PENDING flip. */
+	onTimeout: zod.z.enum(["flip", "hold"]).default("hold")
+});
 var SceneMonitorSchema = zod.z.object({
 	id: zod.z.string(),
 	label: zod.z.string(),
@@ -27353,7 +27505,41 @@ var SceneMonitorSchema = zod.z.object({
 	lastConfidence: zod.z.number().nullable(),
 	currentCondition: SceneConditionSchema.nullable(),
 	availability: zod.z.enum(["ok", "unavailable"]),
-	unavailableReason: zod.z.string().nullable()
+	unavailableReason: zod.z.string().nullable(),
+	/** Which state is "the initial screen". `null` until the first capture. */
+	baselineStateId: zod.z.string().nullable(),
+	/** Which boolean drives notification rules and any export. */
+	emit: zod.z.enum(["latched", "live"]).default("latched"),
+	/** Live: does the region match the baseline RIGHT NOW. */
+	verdict: SceneVerdictSchema,
+	/** Has it been `diverged` at least once since `armedAt` — the operator's boolean. */
+	latched: zod.z.boolean(),
+	/** Last reset (or creation). */
+	armedAt: zod.z.number(),
+	divergedAt: zod.z.number().nullable(),
+	restoredAt: zod.z.number().nullable(),
+	/** A check is only COUNTED when the device has been quiet this long. Motion
+	*  during the window DISCARDS the observation — a car pulling up in front of
+	*  the bin must not be able to spend hysteresis credit. */
+	quietSeconds: zod.z.number().int().min(0).max(3600).default(60),
+	/** An observation only advances the pending count when it is at least this
+	*  far from the previously counted one, so N agreeing checks span real time
+	*  rather than N adjacent polls inside one occlusion. */
+	minObservationSpacingSec: zod.z.number().int().min(0).max(3600).default(120),
+	/** Vision-model adjudication of a candidate flip. Similarity primary only. */
+	confirm: SceneConfirmSchema.optional(),
+	/** Whole-frame anchor cosine below which a flip is REFUSED as `view-shifted`. */
+	anchorThreshold: zod.z.number().min(0).max(1).default(SCENE_DEFAULT_ANCHOR_THRESHOLD),
+	/** Clear the latch on its own when the scene matches again? Default false —
+	*  `restoredAt` and the `scene-restored` edge are recorded regardless, so an
+	*  automation can react to the bin coming back without the operator's own
+	*  alarm silently clearing itself. */
+	autoRestore: zod.z.boolean().default(false),
+	/** Named cause when `verdict === 'unknown'`. */
+	unavailable: SceneUnavailableSchema.nullable(),
+	/** Conditions that have at least one comparable reference — the coverage line
+	*  ("day ✓ · ir ✓ · dusk ✗") that turns a silent fallback into a visible fact. */
+	coveredConditions: zod.z.array(SceneConditionSchema)
 });
 var SceneMonitorStatusSchema = zod.z.object({
 	monitors: zod.z.array(SceneMonitorSchema),
@@ -27402,7 +27588,14 @@ var sceneMonitorCapability = {
 					"both"
 				]).optional(),
 				checkIntervalSec: zod.z.number().optional(),
-				check: SceneCheckSchema.optional()
+				check: SceneCheckSchema.optional(),
+				emit: zod.z.enum(["latched", "live"]).optional(),
+				quietSeconds: zod.z.number().int().min(0).max(3600).optional(),
+				minObservationSpacingSec: zod.z.number().int().min(0).max(3600).optional(),
+				anchorThreshold: zod.z.number().min(0).max(1).optional(),
+				autoRestore: zod.z.boolean().optional(),
+				/** `null` clears the vision-model adjudicator. */
+				confirm: SceneConfirmSchema.nullable().optional()
 			})
 		}), zod.z.void(), {
 			kind: "mutation",
@@ -27443,6 +27636,26 @@ var sceneMonitorCapability = {
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* Clear the latch, re-arm, and — by default — RE-CAPTURE the baseline for
+		* the CURRENT condition. The bin never goes back in exactly the same spot;
+		* "reset" in the operator's head means *this is the new normal*, and
+		* re-capture is what makes the feature self-healing against slow drift
+		* instead of failing silently weeks later.
+		*
+		* Reachable from three surfaces on this one mutation: the scene card, a
+		* notification button (an `onTrigger` sequence with a `kind:'cap'` step —
+		* no new Notification-Center code at all), and tRPC for scripts.
+		*/
+		resetScene: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			monitorId: zod.z.string(),
+			/** Defaults to TRUE at the provider seam — see `SCENE_RESET_RECAPTURES`. */
+			recapture: zod.z.boolean().optional()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	},
 	status: {
@@ -37403,6 +37616,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"sceneMonitor.resetScene": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"sceneMonitor.updateScene": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -40342,6 +40561,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"sceneMonitor.resetScene": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"sceneMonitor.updateScene": [{
 		name: "deviceId",
 		form: "single",
@@ -45382,6 +45606,15 @@ exports.RunnerFrameSourceSchema = RunnerFrameSourceSchema;
 exports.RunnerInferenceDeviceSchema = RunnerInferenceDeviceSchema;
 exports.RunnerLocalLoadSchema = RunnerLocalLoadSchema;
 exports.RunnerLocalMetricsSchema = RunnerLocalMetricsSchema;
+exports.SCENE_CONDITIONS = SCENE_CONDITIONS;
+exports.SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX;
+exports.SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = SCENE_CONFIRM_DEFAULT_TIMEOUT_MS;
+exports.SCENE_DEFAULT_ANCHOR_THRESHOLD = SCENE_DEFAULT_ANCHOR_THRESHOLD;
+exports.SCENE_DEFAULT_CHECK_INTERVAL_SEC = SCENE_DEFAULT_CHECK_INTERVAL_SEC;
+exports.SCENE_DEFAULT_OBSERVATION_SPACING_SEC = SCENE_DEFAULT_OBSERVATION_SPACING_SEC;
+exports.SCENE_DEFAULT_QUIET_SECONDS = SCENE_DEFAULT_QUIET_SECONDS;
+exports.SCENE_DIVERGED = SCENE_DIVERGED;
+exports.SCENE_RESET_RECAPTURES = SCENE_RESET_RECAPTURES;
 exports.SCOPE_PRESETS = SCOPE_PRESETS;
 exports.SCRUB_THUMBNAIL_PRESETS = SCRUB_THUMBNAIL_PRESETS;
 exports.SCRUB_THUMBNAIL_PRESET_LABELS = SCRUB_THUMBNAIL_PRESET_LABELS;
@@ -45396,10 +45629,13 @@ exports.SYSTEM_CAP_NAMES = SYSTEM_CAP_NAMES;
 exports.SYSTEM_SCOPE_DEVICE_METHODS = SYSTEM_SCOPE_DEVICE_METHODS;
 exports.SceneCheckSchema = SceneCheckSchema;
 exports.SceneConditionSchema = SceneConditionSchema;
+exports.SceneConfirmSchema = SceneConfirmSchema;
 exports.SceneMonitorSchema = SceneMonitorSchema;
 exports.SceneMonitorStateSchema = SceneMonitorStateSchema;
 exports.SceneMonitorStatusSchema = SceneMonitorStatusSchema;
 exports.SceneReferenceSchema = SceneReferenceSchema;
+exports.SceneUnavailableSchema = SceneUnavailableSchema;
+exports.SceneVerdictSchema = SceneVerdictSchema;
 exports.ScopedTokenSchema = ScopedTokenSchema;
 exports.ScopedTokenSummarySchema = ScopedTokenSummarySchema;
 exports.ScoredObjectEventSchema = ScoredObjectEventSchema;