@camstack/addon-post-analysis 1.2.196 → 1.2.198

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as audioModeOf, A as NcSnoozeSchema, At as BaseAddon, B as SCENE_DEFAULT_UNCOVERED_POLICY, Bt as boolean, C as NcConditionDescriptorSchema, Ct as sceneMonitorCapability, D as NcRuleTargetSchema, Dt as videoclipsCapability, E as NcRuleSchema, Et as vectorDimFromBase64, Ft as isDeviceScopedCap, G as TimelapseRulePatchSchema, Gt as partialRecord, H as SceneMonitorSchema, Ht as literal, I as RECORDING_EXPORT_MAX_READ_BYTES, It as nodePin, J as VISIT_MERGE_GAP_MS, Jt as unknown, K as TimelapseRuleSchema, Kt as record, L as RetrainStatusSchema, Lt as sleep$1, M as NcSystemEventKindSchema, Mt as DeviceType, N as NcTaxonomySchema, Nt as createEvent, O as NcScheduleSchema, Ot as zoneAnalyticsCapability, P as OpsLogEntrySchema, Pt as hydrateSchema, Q as audioMetricsCapability, Rt as _enum, S as NC_TAXONOMY, T as NcRulePatchSchema, Tt as systemEventFilterApplies, U as TIMELAPSE_DENSE_FLOOR_SEC, Ut as number, V as SCENE_DIVERGED, Vt as discriminatedUnion, W as TimelapseRuleInputSchema, Wt as object, X as alarmPanelCapability, Y as addonWidgetsSourceCapability, Yt as EventCategory, Z as assertTimelapseCadences, _ as MediaFileKindEnum, _t as pickClusterStepModels, a as DEFAULT_EVENT_COLOR, b as NC_DEFAULT_SNOOZE_MINUTES, bt as readDeviceStateFrom, c as DETECTION_MACRO_CLASSES, ct as faceGalleryCapability, d as EVENT_KIND_BY_CAP, dt as isDetectionMacroClass, et as buildEventKindDescriptor, f as EVENT_PAD_MS, ft as isScheduleActive, g as MACRO_LABELS, h as LabelAttributionSchema, ht as notificationRulesCapability, i as COCO_TO_MACRO, it as deriveRecordingMode, j as NcSnoozeSuppressedSchema, jt as CamProfileSchema, k as NcSnoozeInputSchema, kt as errMsg$1, lt as failureContributionCapability, m as FailureCounters, mt as kebabToCamel, n as BaseDevice, nt as customAction, ot as encodeVectorBase64, p as FULL_IMAGE_BBOX, pt as isSourceCap, q as TrackSourceSchema, qt as string, r as CLUSTER_MODEL_SCOPED_STEPS, rt as defineCustomActions, st as evaluateSensorEdge, t as AUDIO_MACRO_LABELS, tt as cosineSimilarity$1, u as DeclaredDevices, v as NC_ALARM_SYSTEM_EVENT_KINDS, vt as pipelineAnalyticsCapability, w as NcRuleInputSchema, wt as subKindsOf, xt as readTimelapseGeneratedAt, y as NC_CONDITION_CATALOG, yt as plateGalleryCapability, z as SCENE_DEFAULT_ANCHOR_THRESHOLD, zt as array } from "../dist-Cu4sfuYT.mjs";
+import { $ as audioModeOf, $t as EventCategory, A as NcSnoozeSchema, At as vectorDimFromBase64, B as SCENE_DEFAULT_UNCOVERED_POLICY, Bt as nodePin, C as NcConditionDescriptorSchema, Ct as readTimelapseGeneratedAt, D as NcRuleTargetSchema, Dt as storageOccupancyCapability, E as NcRuleSchema, Et as sceneMonitorCapability, Ft as CamProfileSchema, G as TimelapseRulePatchSchema, Gt as discriminatedUnion, H as SceneMonitorSchema, Ht as _enum, I as RECORDING_EXPORT_MAX_READ_BYTES, It as DeviceType, J as VISIT_MERGE_GAP_MS, Jt as object, K as TimelapseRuleSchema, Kt as literal, L as RetrainStatusSchema, Lt as createEvent, M as NcSystemEventKindSchema, Mt as zoneAnalyticsCapability, N as NcTaxonomySchema, Nt as errMsg$1, O as NcScheduleSchema, Ot as subKindsOf, P as OpsLogEntrySchema, Pt as BaseAddon, Q as audioMetricsCapability, Qt as unknown, Rt as hydrateSchema, S as NC_TAXONOMY, St as readDeviceStateFrom, T as NcRulePatchSchema, U as TIMELAPSE_DENSE_FLOOR_SEC, Ut as array, V as SCENE_DIVERGED, Vt as sleep$1, W as TimelapseRuleInputSchema, Wt as boolean, X as alarmPanelCapability, Xt as record, Y as addonWidgetsSourceCapability, Yt as partialRecord, Z as assertTimelapseCadences, Zt as string, _ as MediaFileKindEnum, _t as notificationRulesCapability, a as DEFAULT_EVENT_COLOR, b as NC_DEFAULT_SNOOZE_MINUTES, bt as pipelineAnalyticsCapability, c as DETECTION_MACRO_CLASSES, ct as evictionPolicyOfLocation, d as EVENT_KIND_BY_CAP, et as buildEventKindDescriptor, f as EVENT_PAD_MS, ft as isDetectionMacroClass, g as MACRO_LABELS, gt as mayWriteToLocation, h as LabelAttributionSchema, ht as kebabToCamel, i as COCO_TO_MACRO, it as deriveRecordingMode, j as NcSnoozeSuppressedSchema, jt as videoclipsCapability, k as NcSnoozeInputSchema, kt as systemEventFilterApplies, lt as faceGalleryCapability, m as FailureCounters, mt as isSourceCap, n as BaseDevice, nt as customAction, ot as encodeVectorBase64, p as FULL_IMAGE_BBOX, pt as isScheduleActive, q as TrackSourceSchema, qt as number, r as CLUSTER_MODEL_SCOPED_STEPS, rt as defineCustomActions, st as evaluateSensorEdge, t as AUDIO_MACRO_LABELS, tt as cosineSimilarity$1, u as DeclaredDevices, ut as failureContributionCapability, v as NC_ALARM_SYSTEM_EVENT_KINDS, w as NcRuleInputSchema, wt as resolveLocationMode, xt as plateGalleryCapability, y as NC_CONDITION_CATALOG, yt as pickClusterStepModels, z as SCENE_DEFAULT_ANCHOR_THRESHOLD, zt as isDeviceScopedCap } from "../dist-BrszC4uJ.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs from "node:fs";
 import { promises } from "node:fs";
@@ -9,6 +9,45 @@ import { execFile } from "node:child_process";
 import sharp from "sharp";
 import os from "node:os";
 import { Buffer as Buffer$1 } from "node:buffer";
+//#region src/pipeline-analytics/media-occupancy.ts
+/** The bare type ref legacy NULL-stamped media rows belong to. */
+var LEGACY_MEDIA_TYPE = "eventMedia";
+/**
+* Which of the requested locations the legacy `eventMedia` rows belong to, or
+* `null` when it cannot be decided — the same rule `resolveRef` applies, and
+* the same refusal when it is ambiguous.
+*/
+function legacyMediaLocationOf(locationIds) {
+	const ofType = locationIds.filter((id) => id.startsWith(`${LEGACY_MEDIA_TYPE}:`));
+	if (ofType.length === 1) return ofType[0] ?? null;
+	return ofType.find((id) => id === `eventMedia:default`) ?? null;
+}
+/**
+* The occupancy reports for one measurement.
+*
+* A location with nothing on it is OMITTED, not reported as zero: only the
+* orchestrator knows whether nobody reported for a location or every reporter
+* holds nothing there, and it is the one that must be able to tell them apart.
+*/
+function mediaOccupancyReports(footprint, locationIds, measuredAtMs) {
+	const bytesByLocation = new Map(footprint.byLocation);
+	const legacyTarget = footprint.legacyNullBytes > 0 ? legacyMediaLocationOf(locationIds) : null;
+	if (legacyTarget !== null) bytesByLocation.set(legacyTarget, (bytesByLocation.get(legacyTarget) ?? 0) + footprint.legacyNullBytes);
+	const reports = [];
+	for (const [locationId, ownedBytes] of bytesByLocation) {
+		if (ownedBytes <= 0) continue;
+		reports.push({
+			locationId,
+			ownedBytes,
+			measuredAtMs
+		});
+	}
+	return {
+		reports,
+		unattributedBytes: legacyTarget === null ? footprint.legacyNullBytes : 0
+	};
+}
+//#endregion
 //#region src/notification-center/action-token.ts
 /**
 * The authority behind a notification button.
@@ -28857,6 +28896,50 @@ var MediaStore = class {
 		return out;
 	}
 	/**
+	* Bytes this store holds on each of the named storage locations (D388).
+	*
+	* One indexed aggregate per location (`idx_media_location`), plus one for the
+	* legacy NULL-stamped rows — `locationId IS NULL` means "wherever the bare
+	* `eventMedia` type ref resolves", and the CALLER attributes those, because
+	* resolving a bare type ref is the orchestrator's rule and not this store's.
+	*
+	* A location this store holds nothing on is OMITTED, never reported as zero:
+	* the difference between "we hold nothing here" and "nobody asked" is the
+	* whole point of the occupancy contract, and only the caller can tell which
+	* it is. A read that fails THROWS rather than degrading to zeros — the same
+	* rule `footprintByDevice` follows, for the same reason.
+	*/
+	async footprintByLocation(locationIds) {
+		const byLocation = /* @__PURE__ */ new Map();
+		for (const locationId of locationIds) {
+			const agg = await this.store.aggregate.query({
+				collection: MEDIA_COLLECTION,
+				fields: [{
+					as: "bytes",
+					field: "sizeBytes",
+					op: "sum"
+				}],
+				filter: { where: { locationId } }
+			});
+			const bytes = agg.values["bytes"] ?? 0;
+			if (agg.count === 0 || bytes <= 0) continue;
+			byLocation.set(locationId, bytes);
+		}
+		const legacy = await this.store.aggregate.query({
+			collection: MEDIA_COLLECTION,
+			fields: [{
+				as: "bytes",
+				field: "sizeBytes",
+				op: "sum"
+			}],
+			filter: { where: { locationId: null } }
+		});
+		return {
+			byLocation,
+			legacyNullBytes: legacy.count === 0 ? 0 : legacy.values["bytes"] ?? 0
+		};
+	}
+	/**
 	* The media footprint broken down by KIND — fleet-wide, or for one camera.
 	*
 	* `footprintByDevice` answers "how much is where"; this answers "how much is
@@ -42066,21 +42149,16 @@ async function wipeClassSubtrees(input) {
 }
 //#endregion
 //#region src/pipeline-analytics/retention/location-discard-policy.ts
-/**
-* Server-side eligibility for discarding a frozen location's leftover
-* class subtree. Same rules as the admin-ui card: frozen, known class,
-* writable sibling of the same type. The last writable of a type is
-* refused here even if the UI is bypassed.
-*/
 var DISCARD_SUBTREES = {
 	eventMedia: ["events"],
 	recordingsLow: ["low"],
 	recordings: ["high", "mid"]
 };
+/** Frozen = the system will not remove this footage on its own: eviction
+*  policy `never` (D385), i.e. `readonly` or `disabled`. A `drain` location is
+*  NOT frozen — the ratchet is already removing it. */
 function locationIsFrozen(location) {
-	const enabled = location.enabled !== false;
-	const readOnly = location.config["readOnly"] === true;
-	return !enabled || readOnly;
+	return evictionPolicyOfLocation(location) === "never";
 }
 function discardEligible(location, siblings) {
 	if (!(location.type in DISCARD_SUBTREES)) return false;
@@ -42088,9 +42166,7 @@ function discardEligible(location, siblings) {
 	return siblings.some((s) => {
 		if (s.id === location.id) return false;
 		if (s.type !== location.type) return false;
-		const enabled = s.enabled !== false;
-		const readOnly = s.config["readOnly"] === true;
-		return enabled && !readOnly;
+		return mayWriteToLocation(s);
 	});
 }
 function assertDiscardAllowed(location, all, localNodeId) {
@@ -50711,13 +50787,22 @@ var MediaCaptureLogAggregator = class {
 * when none is writable — the caller MUST refuse the write rather than fall
 * back to a read-only location, which would fail far downstream as an opaque
 * filesystem error instead of a named storage decision.
+*
+* `stickyId` is the pick this process last made (absent on a cold start). It
+* used to be the CLASS DEFAULT, which is gone (D383): the write set is every
+* enabled location, and among them the emptiest wins. Cross-restart stickiness
+* is deliberately not durable — every blob row stamps its own `locationId`, so
+* a restart that switches disk splits nothing that reads wrong.
 */
-function pickWritableMediaLocation(locations, currentDefaultId) {
-	const writable = locations.filter((l) => l.enabled && !l.readOnly);
+function pickWritableMediaLocation(locations, stickyId) {
+	const writable = locations.filter((l) => mayWriteToLocation({
+		mode: l.mode,
+		config: {}
+	}));
 	if (writable.length === 0) return null;
-	const keep = writable.find((l) => l.id === currentDefaultId);
+	const keep = stickyId === void 0 ? void 0 : writable.find((l) => l.id === stickyId);
 	if (keep) return keep.id;
-	return writable.toSorted((a, b) => b.headroomBytes - a.headroomBytes)[0]?.id ?? null;
+	return writable.toSorted((a, b) => b.headroomBytes - a.headroomBytes || a.id.localeCompare(b.id))[0]?.id ?? null;
 }
 //#endregion
 //#region src/pipeline-analytics/media-relocate-engine.ts
@@ -67372,6 +67457,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	* `enabled` flags only change via operator reconfig.
 	*/
 	eventMediaWriteLocationCache = null;
+	/**
+	* The last location this process actually picked for an `eventMedia` write.
+	* Survives the cache invalidation a migration performs, so a refresh keeps
+	* writing where it was writing while that stays writable — the stickiness the
+	* class default used to provide before it was deleted (D383).
+	*/
+	lastEventMediaWritePick = null;
 	mediaWriteGate = new MediaWriteGate();
 	storageMigrationLeaseId = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
@@ -68716,9 +68808,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	}
 	/**
 	* Resolves which `eventMedia` location a NEW footage-class blob should be
-	* written to (`MediaStoreDeps.resolveEventMediaLocation`). Reflects
-	* `config.readOnly` — an operator draining a location marks it read-only,
-	* and new writes must never land there (the relocate mover, exposed as
+	* written to (`MediaStoreDeps.resolveEventMediaLocation`). Reflects the
+	* location's `mode` (D385) — a location the operator has taken out of the
+	* write set never receives new blobs (the relocate mover, exposed as
 	* `relocateMedia`, empties what is already on it in the background).
 	*
 	* Cached after the first successful resolution — this is a per-blob write
@@ -68733,6 +68825,32 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	* a test harness that never wires `api.storage`) must not turn every media
 	* write into a hard failure the way "no writable location" does.
 	*/
+	/**
+	* The `storage-occupancy` answer for event media (D388) — bytes HELD on each
+	* named location, not bytes retention would be willing to remove.
+	*
+	* Answered from ONE indexed aggregate per location. A store that is not up
+	* yet reports NOTHING, which reads as unknown; it never reports zeros, which
+	* would claim the disks are empty. Legacy NULL-stamped rows are attributed by
+	* `mediaOccupancyReports`, and bytes it cannot place are LOGGED rather than
+	* spread over the candidates — a number no disk agrees with is worse than an
+	* absent one.
+	*/
+	async mediaOccupancy(locationIds) {
+		const store = this.mediaStore;
+		if (!store) return [];
+		const { reports, unattributedBytes } = mediaOccupancyReports(await store.footprintByLocation(locationIds), locationIds, Date.now());
+		if (unattributedBytes > 0 && !this.mediaOccupancyUnattributedLogged) {
+			this.mediaOccupancyUnattributedLogged = true;
+			this.ctx.logger.warn("pipeline-analytics: event-media bytes could not be attributed to a location — the legacy `eventMedia` type ref resolves to no single location, so they are reported NOWHERE rather than onto a disk that does not hold them", { meta: {
+				unattributedBytes,
+				locationIds: [...locationIds]
+			} });
+		}
+		return reports;
+	}
+	/** One line per process: this repeats on every occupancy refresh otherwise. */
+	mediaOccupancyUnattributedLogged = false;
 	async resolveEventMediaWriteLocation(api, logger, deviceId) {
 		const cached = this.eventMediaWriteLocationCache;
 		if (cached !== null) return cached;
@@ -68746,10 +68864,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		}
 		const picked = pickWritableMediaLocation(locations.map((l) => ({
 			id: l.id,
-			readOnly: l.config["readOnly"] === true,
-			enabled: l.enabled !== false,
+			mode: resolveLocationMode(l),
 			headroomBytes: l.capacity?.availableBytes ?? 0
-		})), locations.find((l) => l.isDefault)?.id ?? "eventMedia");
+		})), this.lastEventMediaWritePick ?? void 0);
 		if (picked === null) {
 			const seen = locations.length > 0 ? locations.map((l) => l.id).join(", ") : "(none registered)";
 			logger.error("pipeline-analytics: no writable eventMedia storage location — refusing the write instead of failing far downstream as a filesystem error", {
@@ -68759,6 +68876,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			throw new Error(`no writable eventMedia storage location (seen: ${seen})`);
 		}
 		this.eventMediaWriteLocationCache = picked;
+		this.lastEventMediaWritePick = picked;
 		return picked;
 	}
 	/** Constructs every SQLite-backed store plus the stationary/package-drop/
@@ -70703,6 +70821,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				capability: notificationRulesCapability,
 				provider: this.notificationCenter.buildProvider()
 			}] : [],
+			{
+				capability: storageOccupancyCapability,
+				provider: { getOccupancy: async (input) => this.mediaOccupancy(input.locationIds) }
+			},
 			{
 				capability: zoneAnalyticsCapability,
 				provider: providers.zoneAnalytics

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-1iZqrgrt.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-CTKbm1Jm.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.2.196",
+  "version": "1.2.198",
   "description": "Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",
@@ -101,6 +101,10 @@
           },
           {
             "name": "failure-contribution"
+          },
+          {
+            "name": "storage-occupancy",
+            "optional": true
           }
         ],
         "storageLocations": [