@camstack/types 1.2.173 → 1.2.175

package/dist/generated/method-device-selectors.d.ts

@@ -6,8 +6,8 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 369 methods carry a device reference, of which
- * 134 are on SYSTEM-scope caps.
+ * Coverage: 372 methods carry a device reference, of which
+ * 137 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying
  * a numeric device field (targets[].deviceId) are all mapped; the matcher

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_category = require("./event-category-BVo6ta6_.js");
-const require_sleep = require("./sleep-Bo9cUOXp.js");
+const require_event_category = require("./event-category-BNJ9EE5B.js");
+const require_sleep = require("./sleep-CTHjJilA.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");
@@ -10202,7 +10202,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. */
@@ -10215,7 +10215,7 @@ var SourceInfoSchema = zod.z.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.
@@ -10974,7 +10974,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.
@@ -16517,7 +16517,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
 	*
@@ -19414,6 +19414,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"),
@@ -19438,6 +19445,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(),
 	/**
@@ -21139,6 +21175,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
@@ -21528,7 +21618,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"]),
@@ -22098,7 +22188,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: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			/** Opaque to the runner — the hub's track id. */
+			trackId: zod.z.string(),
+			kind: ParkedFrameKindSchema,
+			handle: require_sleep.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: require_sleep.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: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			trackId: zod.z.string()
+		}), zod.z.object({ released: zod.z.number().int().nonnegative() }), { kind: "mutation" })
 	}
 };
 //#endregion
@@ -26518,8 +26661,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.
@@ -26677,7 +26820,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
@@ -29000,7 +29143,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"]),
@@ -33237,13 +33380,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.
 	*
@@ -33253,7 +33414,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({
@@ -33291,6 +33469,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
@@ -38294,7 +38483,7 @@ function toDeviceSummary(device, addonId) {
 	};
 }
 /**
-* Base class for device-provider addons (rtsp, onvif, frigate).
+* Base class for device-provider addons (rtsp, onvif).
 *
 * Provides default implementations for the common device-provider cap
 * methods (`start`, `stop`, `getStatus`, `getDevices`, `supportsDiscovery`,
@@ -45750,6 +45939,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",
@@ -49296,6 +49503,21 @@ var METHOD_DEVICE_SELECTORS = 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",
@@ -49975,6 +50197,9 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"pipelineRunner.attachCamera",
 	"pipelineRunner.detachCamera",
 	"pipelineRunner.getCameraMetrics",
+	"pipelineRunner.getParkedTrackFrame",
+	"pipelineRunner.parkTrackFrame",
+	"pipelineRunner.releaseParkedTrackFrames",
 	"pipelineRunner.reportMotion",
 	"pipelineRunner.runDetailSubtree",
 	"pipelineRunner.runStatelessStep",
@@ -52239,7 +52464,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
@@ -55763,6 +55988,10 @@ exports.PROVIDER_KIND_CAP_NAMES = PROVIDER_KIND_CAP_NAMES;
 exports.PYTHON_SCRIPT = PYTHON_SCRIPT;
 exports.PackageUpdateSchema = PackageUpdateSchema;
 exports.PackageVersionInfoSchema = PackageVersionInfoSchema;
+exports.ParkRefusalSchema = ParkRefusalSchema;
+exports.ParkTrackFrameResultSchema = ParkTrackFrameResultSchema;
+exports.ParkedFrameKindSchema = ParkedFrameKindSchema;
+exports.ParkedTrackFrameSchema = ParkedTrackFrameSchema;
 exports.PasskeyLoginMethodSchema = PasskeyLoginMethodSchema;
 exports.PasskeySummarySchema = PasskeySummarySchema;
 exports.PcmSampleFormatSchema = PcmSampleFormatSchema;