@camstack/addon-post-analysis 1.2.127 → 1.2.128

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as customAction, A as NcTaxonomySchema, At as sleep, B as TIMELAPSE_DENSE_FLOOR_SEC, Bt as string, C as NcRuleSchema, Ct as errMsg, D as NcSnoozeSchema, Dt as hydrateSchema, E as NcSnoozeInputSchema, Et as createEvent, Ft as literal, G as VISIT_MERGE_GAP_MS, H as TimelapseRulePatchSchema, Ht as EventCategory, I as SCENE_DEFAULT_ANCHOR_THRESHOLD, It as number, J as assertTimelapseCadences, K as addonWidgetsSourceCapability, L as SCENE_DEFAULT_UNCOVERED_POLICY, Lt as object, Mt as array, N as RECORDING_EXPORT_MAX_READ_BYTES, Nt as boolean, O as NcSnoozeSuppressedSchema, Ot as isDeviceScopedCap, P as RetrainStatusSchema, Pt as discriminatedUnion, Q as cosineSimilarity$1, R as SCENE_DIVERGED, Rt as partialRecord, S as NcRulePatchSchema, St as zoneAnalyticsCapability, T as NcScheduleSchema, Tt as DeviceType, U as TimelapseRuleSchema, V as TimelapseRuleInputSchema, Vt as unknown, W as TrackSourceSchema, X as audioModeOf, Y as audioMetricsCapability, Z as buildEventKindDescriptor, _ as NC_DEFAULT_SNOOZE_MINUTES, _t as sceneMonitorCapability, a as DEFAULT_EVENT_COLOR, b as NcConditionDescriptorSchema, bt as vectorDimFromBase64, ct as kebabToCamel, d as EVENT_PAD_MS, dt as pickClusterStepModels, et as defineCustomActions, f as FULL_IMAGE_BBOX, ft as pipelineAnalyticsCapability, g as NC_CONDITION_CATALOG, h as NC_ALARM_SYSTEM_EVENT_KINDS, ht as readTimelapseGeneratedAt, i as CLUSTER_MODEL_SCOPED_STEPS, it as faceGalleryCapability, j as OpsLogEntrySchema, jt as _enum, k as NcSystemEventKindSchema, kt as nodePin, l as DeclaredDevices, lt as notificationRulesCapability, m as MACRO_LABELS, mt as readDeviceStateFrom, n as AnalyticsGroupRecordSchema, ot as isDetectionMacroClass, p as LabelAttributionSchema, pt as plateGalleryCapability, q as alarmPanelCapability, r as BaseDevice, rt as encodeVectorBase64, s as DETECTION_MACRO_CLASSES, st as isScheduleActive, t as AnalyticsGroupDetailSchema, tt as deriveRecordingMode, u as EVENT_KIND_BY_CAP, vt as subKindsOf, w as NcRuleTargetSchema, wt as BaseAddon, x as NcRuleInputSchema, xt as videoclipsCapability, y as NC_TAXONOMY, yt as systemEventFilterApplies, z as SceneMonitorSchema, zt as record } from "../dist-BDy0xpfI.mjs";
+import { $ as customAction, A as NcTaxonomySchema, At as sleep, B as TIMELAPSE_DENSE_FLOOR_SEC, Bt as string, C as NcRuleSchema, Ct as errMsg, D as NcSnoozeSchema, Dt as hydrateSchema, E as NcSnoozeInputSchema, Et as createEvent, Ft as literal, G as VISIT_MERGE_GAP_MS, H as TimelapseRulePatchSchema, Ht as EventCategory, I as SCENE_DEFAULT_ANCHOR_THRESHOLD, It as number, J as assertTimelapseCadences, K as addonWidgetsSourceCapability, L as SCENE_DEFAULT_UNCOVERED_POLICY, Lt as object, Mt as array, N as RECORDING_EXPORT_MAX_READ_BYTES, Nt as boolean, O as NcSnoozeSuppressedSchema, Ot as isDeviceScopedCap, P as RetrainStatusSchema, Pt as discriminatedUnion, Q as cosineSimilarity$1, R as SCENE_DIVERGED, Rt as partialRecord, S as NcRulePatchSchema, St as zoneAnalyticsCapability, T as NcScheduleSchema, Tt as DeviceType, U as TimelapseRuleSchema, V as TimelapseRuleInputSchema, Vt as unknown, W as TrackSourceSchema, X as audioModeOf, Y as audioMetricsCapability, Z as buildEventKindDescriptor, _ as NC_DEFAULT_SNOOZE_MINUTES, _t as sceneMonitorCapability, a as DEFAULT_EVENT_COLOR, b as NcConditionDescriptorSchema, bt as vectorDimFromBase64, ct as kebabToCamel, d as EVENT_PAD_MS, dt as pickClusterStepModels, et as defineCustomActions, f as FULL_IMAGE_BBOX, ft as pipelineAnalyticsCapability, g as NC_CONDITION_CATALOG, h as NC_ALARM_SYSTEM_EVENT_KINDS, ht as readTimelapseGeneratedAt, i as CLUSTER_MODEL_SCOPED_STEPS, it as faceGalleryCapability, j as OpsLogEntrySchema, jt as _enum, k as NcSystemEventKindSchema, kt as nodePin, l as DeclaredDevices, lt as notificationRulesCapability, m as MACRO_LABELS, mt as readDeviceStateFrom, n as AnalyticsGroupRecordSchema, ot as isDetectionMacroClass, p as LabelAttributionSchema, pt as plateGalleryCapability, q as alarmPanelCapability, r as BaseDevice, rt as encodeVectorBase64, s as DETECTION_MACRO_CLASSES, st as isScheduleActive, t as AnalyticsGroupDetailSchema, tt as deriveRecordingMode, u as EVENT_KIND_BY_CAP, vt as subKindsOf, w as NcRuleTargetSchema, wt as BaseAddon, x as NcRuleInputSchema, xt as videoclipsCapability, y as NC_TAXONOMY, yt as systemEventFilterApplies, z as SceneMonitorSchema, zt as record } from "../dist-CRDS5ykk.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs from "node:fs";
 import { promises } from "node:fs";
@@ -31799,11 +31799,13 @@ var MediaStore = class {
 	store;
 	logger;
 	writeGate;
+	resolveEventMediaLocation;
 	constructor(deps) {
 		this.storage = deps.storage;
 		this.store = deps.store;
 		this.logger = deps.logger;
 		this.writeGate = deps.writeGate;
+		this.resolveEventMediaLocation = deps.resolveEventMediaLocation;
 	}
 	gated(mutation) {
 		return this.writeGate ? this.writeGate.run(mutation) : mutation();
@@ -31824,7 +31826,8 @@ var MediaStore = class {
 	async putUnchecked(params) {
 		const key = buildKey(params);
 		const path = buildPath(params);
-		const location = locationForOwnerKind(params.ownerKind);
+		const staticLocation = locationForOwnerKind(params.ownerKind);
+		const location = staticLocation === "eventMedia" && this.resolveEventMediaLocation ? await this.resolveEventMediaLocation(params.deviceId) : staticLocation;
 		const record = {
 			deviceId: params.deviceId,
 			ownerKind: params.ownerKind,
@@ -41478,6 +41481,21 @@ var MediaCaptureLogAggregator = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/media-locations.ts
+/**
+* Picks the location a new `eventMedia` blob should be written to, or `null`
+* 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.
+*/
+function pickWritableMediaLocation(locations, currentDefaultId) {
+	const writable = locations.filter((l) => l.enabled && !l.readOnly);
+	if (writable.length === 0) return null;
+	const keep = writable.find((l) => l.id === currentDefaultId);
+	if (keep) return keep.id;
+	return writable.toSorted((a, b) => b.headroomBytes - a.headroomBytes)[0]?.id ?? null;
+}
+//#endregion
 //#region src/pipeline-analytics/media-relocate-engine.ts
 var PAGE_SIZE = 200;
 var DEFAULT_THROTTLE_MBPS = 40;
@@ -56971,6 +56989,144 @@ function rowFromMetadata(id, metadata) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/store/settings-raw-mirror.ts
+/** How long a mirrored entry is served before a refresh is started behind the
+*  next reader. See the module doc for why this matches the per-kind caches'
+*  own window rather than introducing a second staleness bound. */
+var RAW_SETTINGS_STALE_MS = 5e3;
+/**
+* How long a FAILED refresh is not retried.
+*
+* A refresh that throws leaves `fetchedAt` where it was, so without a
+* cooldown every subsequent reader would start another attempt — a broken
+* settings store would be hammered at frame rate by the very mechanism built
+* to stop that.
+*/
+var RAW_SETTINGS_MISS_COOLDOWN_MS = 5e3;
+/**
+* The addon's per-device raw blob (`pipeline-analytics:addon-devices`), kept
+* fresh OFF every per-kind settings cache's hot path.
+*
+* `resolve` is COLD-awaiting and single-flight: a burst of settings kinds
+* (or frames) missing on the same device in the same tick costs ONE read,
+* not one per caller — the exact failure this class exists to remove.
+*/
+var RawDeviceBlobMirror = class {
+	deps;
+	staleMs;
+	missCooldownMs;
+	entries = /* @__PURE__ */ new Map();
+	inFlight = /* @__PURE__ */ new Map();
+	now;
+	constructor(deps, staleMs = RAW_SETTINGS_STALE_MS, missCooldownMs = RAW_SETTINGS_MISS_COOLDOWN_MS) {
+		this.deps = deps;
+		this.staleMs = staleMs;
+		this.missCooldownMs = missCooldownMs;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	/**
+	* The device's raw stored blob.
+	*
+	* COLD awaits — the first settings kind to touch a device has to get the
+	* real answer. WARM returns immediately, stale or not, and starts the
+	* refresh behind the caller.
+	*/
+	async resolve(deviceId) {
+		const entry = this.entries.get(deviceId);
+		if (entry === void 0) return this.load(deviceId);
+		if (this.now() - entry.fetchedAt >= this.staleMs) this.load(deviceId);
+		return entry.value;
+	}
+	/** Drop a device's entry. Called by every in-process writer of this
+	*  device's row, so an operator's own change is never served stale. */
+	invalidate(deviceId) {
+		this.entries.delete(deviceId);
+	}
+	invalidateAll() {
+		this.entries.clear();
+	}
+	async load(deviceId) {
+		const pending = this.inFlight.get(deviceId);
+		if (pending !== void 0) return pending;
+		const run = this.deps.read(deviceId).then((value) => {
+			this.entries.set(deviceId, {
+				value,
+				fetchedAt: this.now()
+			});
+			return value;
+		}).catch((err) => {
+			this.deps.onRefreshFailed?.(deviceId, err);
+			const existing = this.entries.get(deviceId);
+			if (existing !== void 0) {
+				existing.fetchedAt = this.now() - this.staleMs + this.missCooldownMs;
+				return existing.value;
+			}
+			return {};
+		}).finally(() => {
+			this.inFlight.delete(deviceId);
+		});
+		this.inFlight.set(deviceId, run);
+		return run;
+	}
+};
+/**
+* The addon's ONE `addon_settings` row (`pipeline-analytics:addon-settings`),
+* kept fresh OFF every per-kind settings cache's hot path. Same shape as
+* {@link RawDeviceBlobMirror}, singleton rather than keyed — there is exactly
+* one addon store per process.
+*/
+var RawGlobalStoreMirror = class {
+	deps;
+	staleMs;
+	missCooldownMs;
+	entry = null;
+	inFlight = null;
+	now;
+	constructor(deps, staleMs = RAW_SETTINGS_STALE_MS, missCooldownMs = RAW_SETTINGS_MISS_COOLDOWN_MS) {
+		this.deps = deps;
+		this.staleMs = staleMs;
+		this.missCooldownMs = missCooldownMs;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	async resolve() {
+		const entry = this.entry;
+		if (entry === null) return this.load();
+		if (this.now() - entry.fetchedAt >= this.staleMs) this.load();
+		return entry.value;
+	}
+	/** Drop the mirrored store. Called by every in-process global-settings
+	*  writer (`onConfigChanged`), so an operator's own change is never served
+	*  stale. */
+	invalidate() {
+		this.entry = null;
+	}
+	async load() {
+		if (this.inFlight !== null) return this.inFlight;
+		const run = this.deps.read().then((value) => {
+			this.entry = {
+				value,
+				fetchedAt: this.now()
+			};
+			return value;
+		}).catch((err) => {
+			this.deps.onRefreshFailed?.(err);
+			const existing = this.entry;
+			if (existing !== null) {
+				this.entry = {
+					value: existing.value,
+					fetchedAt: this.now() - this.staleMs + this.missCooldownMs
+				};
+				return existing.value;
+			}
+			return {};
+		}).finally(() => {
+			this.inFlight = null;
+		});
+		this.inFlight = run;
+		return run;
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/track-retention-sweep.ts
 /**
 * Sweep every device with persisted tracks: skip retention-disabled devices,
@@ -58027,6 +58183,14 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	/** Event-media relocation engine (entity-routing Phase 4). */
 	mediaRelocate = null;
 	mediaLocationStorage = null;
+	/**
+	* Cached pick for NEW `eventMedia` writes (`pickWritableMediaLocation`).
+	* Resolved once, never per blob (no-RPC-per-blob, same discipline as
+	* `mediaLocationStorage`'s own root cache) — dropped together with it by
+	* `refreshStorageLocationsForMigration`, since a location's `readOnly` /
+	* `enabled` flags only change via operator reconfig.
+	*/
+	eventMediaWriteLocationCache = null;
 	mediaWriteGate = new MediaWriteGate();
 	storageMigrationLeaseId = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
@@ -58426,6 +58590,33 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	audioEpisodeTracks = /* @__PURE__ */ new Map();
 	audioEpisodeLastPersistMs = /* @__PURE__ */ new Map();
 	settingsCaches = new DeviceSettingsCacheHub();
+	/**
+	* The addon-level store and per-device blob, mirrored ONCE and shared by
+	* every settings kind above — see `store/settings-raw-mirror.ts`. Before
+	* this, each kind's cache miss called `resolveGlobalStore()` +
+	* `readDeviceBlob()` directly, so eight kinds expiring in the same window
+	* paid for the same two reads eight times: `get
+	* pipeline-analytics:addon-settings` at 547–694/min, `get
+	* pipeline-analytics:addon-devices` at ~700/min, live 2026-08-26. Invalidated
+	* by every in-process writer: `applyDeviceSettingsPatch` and the retired-
+	* setting purges drop the device mirror, `onConfigChanged` (this process's
+	* own `updateGlobalSettings`) drops the global mirror.
+	*/
+	rawDeviceBlobMirror = new RawDeviceBlobMirror({
+		read: (deviceId) => this.readDeviceBlob(deviceId),
+		onRefreshFailed: (deviceId, err) => {
+			this.ctx.logger.debug("raw device-blob mirror refresh failed — serving last value", {
+				tags: { deviceId },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+		}
+	});
+	rawGlobalStoreMirror = new RawGlobalStoreMirror({
+		read: () => this.resolveGlobalStore(),
+		onRefreshFailed: (err) => {
+			this.ctx.logger.debug("raw global-store mirror refresh failed — serving last value", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	});
 	/** Avoids a store read every ~30 Hz audio frame. */
 	audioSettingsCache = this.settingsCaches.registerDeviceCache("audio-detection", SETTINGS_CACHE_TTL_MS);
 	sensitivitySettingsCache = this.settingsCaches.registerDeviceCache("detection-sensitivity", SETTINGS_CACHE_TTL_MS);
@@ -59145,6 +59336,53 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		this.mediaLocationStorage = routed;
 		return routed;
 	}
+	/**
+	* 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
+	* `relocateMedia`, empties what is already on it in the background).
+	*
+	* Cached after the first successful resolution — this is a per-blob write
+	* path, and the write-side provider is a declared no-RPC-per-blob bypass
+	* (D-note in `location-aware-media-storage.ts`); re-querying the storage
+	* cap on every blob would undo that. Dropped by
+	* `refreshStorageLocationsForMigration`, same trigger as
+	* `mediaLocationStorage.invalidateRoots()`.
+	*
+	* Degrades to the bare `eventMedia` type ref (pre-2026-08-26 behaviour)
+	* when the storage cap itself is unreachable — a transient RPC failure (or
+	* a test harness that never wires `api.storage`) must not turn every media
+	* write into a hard failure the way "no writable location" does.
+	*/
+	async resolveEventMediaWriteLocation(api, logger, deviceId) {
+		const cached = this.eventMediaWriteLocationCache;
+		if (cached !== null) return cached;
+		let locations;
+		try {
+			locations = await api.storage.listLocations.query({ type: DEFAULT_MEDIA_LOCATION });
+		} catch (err) {
+			logger.debug("pipeline-analytics: eventMedia location list unavailable — writing through the default ref", { meta: { error: errMsg(err) } });
+			this.eventMediaWriteLocationCache = DEFAULT_MEDIA_LOCATION;
+			return DEFAULT_MEDIA_LOCATION;
+		}
+		const picked = pickWritableMediaLocation(locations.map((l) => ({
+			id: l.id,
+			readOnly: l.config["readOnly"] === true,
+			enabled: l.enabled !== false,
+			headroomBytes: l.capacity?.availableBytes ?? 0
+		})), locations.find((l) => l.isDefault)?.id ?? "eventMedia");
+		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", {
+				tags: { deviceId },
+				meta: { locationsSeen: seen }
+			});
+			throw new Error(`no writable eventMedia storage location (seen: ${seen})`);
+		}
+		this.eventMediaWriteLocationCache = picked;
+		return picked;
+	}
 	/** Constructs every SQLite-backed store plus the stationary/package-drop/
 	*  sensor plumbing, in the exact pre-S7 order. Returns the non-null bundle
 	*  so the rest of boot consumes the stores without re-narrowing. */
@@ -59203,7 +59441,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			storage,
 			store: api.settingsStore,
 			logger: logger.child("MediaStore"),
-			writeGate: this.mediaWriteGate
+			writeGate: this.mediaWriteGate,
+			resolveEventMediaLocation: (deviceId) => this.resolveEventMediaWriteLocation(api, logger, deviceId)
 		});
 		this.mediaStore = mediaStore;
 		const retrainFrames = new RetrainFrameStore({
@@ -60511,6 +60750,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			this.forgetDeviceProcessors(data.deviceId);
 			this.levelStateByDevice.delete(data.deviceId);
 			this.settingsCaches.clearDevice(data.deviceId);
+			this.rawDeviceBlobMirror.invalidate(data.deviceId);
 		}
 	}
 	/** `DeviceUnregistered` handler — subscription topology lives in
@@ -60535,6 +60775,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		}
 		this.audioMarkers?.forgetDevice(deviceId);
 		this.settingsCaches.clearDevice(deviceId);
+		this.rawDeviceBlobMirror.invalidate(deviceId);
 		this.bindingCache?.invalidate(deviceId);
 		this.detectionCoverage?.forget(deviceId);
 		this.zoneAnalytics?.forgetDevice(deviceId);
@@ -60963,6 +61204,17 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			}] : []
 		];
 	}
+	/**
+	* `BaseAddon.updateGlobalSettings` calls this after the write lands —
+	* gated to the LOCAL node's own write (a sibling-node write returns before
+	* reaching it), which is exactly the scope `rawGlobalStoreMirror` needs to
+	* invalidate: the mirror only ever answers for THIS process, so it only
+	* needs to drop on THIS process's own write (D224).
+	*/
+	async onConfigChanged() {
+		await super.onConfigChanged();
+		this.rawGlobalStoreMirror.invalidate();
+	}
 	async onShutdown() {
 		this.shuttingDown = true;
 		this.sceneEngine?.stop();
@@ -61018,6 +61270,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		this.gatedNodeByDevice.clear();
 		this.levelStateByDevice.clear();
 		this.settingsCaches.clearAll();
+		this.rawDeviceBlobMirror.invalidateAll();
+		this.rawGlobalStoreMirror.invalidate();
 		this.confirmationDetectorStepByNode.clear();
 		this.trackStore?.clearAll();
 		this.stationaryRegistry = null;
@@ -61730,10 +61984,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	*  auto-assigning — see `__tests__/global-settings-cascade.spec.ts`).
 	*  `resolveGlobalStore()` is the sanctioned BaseAddon read (per-node
 	*  projection applied; a raw `readAddonStore` would leak `@node` keys if a
-	*  perNode field is ever declared). */
+	*  perNode field is ever declared).
+	*
+	*  Both raw reads go through `rawGlobalStoreMirror` / `rawDeviceBlobMirror`
+	*  rather than straight to the store: this method is the ONE place all
+	*  eight settings kinds funnel through on a cache miss, so calling the raw
+	*  reads directly here means eight kinds expiring in the same window each
+	*  pay for the same two reads — see `store/settings-raw-mirror.ts`. */
 	async readDeviceSettings(deviceId, resolve) {
-		const globalRaw = this.ctxIfReady !== null ? await this.resolveGlobalStore() : {};
-		const deviceRaw = await this.readDeviceBlob(deviceId);
+		const globalRaw = this.ctxIfReady !== null ? await this.rawGlobalStoreMirror.resolve() : {};
+		const deviceRaw = await this.rawDeviceBlobMirror.resolve(deviceId);
 		return resolve({
 			...globalRaw,
 			...deviceRaw
@@ -63404,6 +63664,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					});
 				}
 				await settings.writeDeviceStore(deviceId, plan.patch);
+				this.rawDeviceBlobMirror.invalidate(deviceId);
 			} catch (err) {
 				this.retiredSettingsChecked.delete(deviceId);
 				this.ctx.logger.warn("retired retention settings migration failed — will retry", {
@@ -63475,6 +63736,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					deviceId
 				});
 				await settings.writeDeviceStore(deviceId, plan.patch);
+				this.rawDeviceBlobMirror.invalidate(deviceId);
 			} catch (err) {
 				this.storedSuggestionCheckedDevices.delete(deviceId);
 				this.ctx.logger.warn("face suggestion threshold purge failed — will retry", {
@@ -65621,6 +65883,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	async refreshStorageLocationsForMigration(input) {
 		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
 		this.mediaLocationStorage?.invalidateRoots();
+		this.eventMediaWriteLocationCache = null;
 		return { refreshed: true };
 	}
 	async startStorageMigrationMove(input) {
@@ -65634,6 +65897,32 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	async cancelStorageMigrationMove(input) {
 		return { cancelled: this.mediaRelocate?.cancel(input.jobId) ?? false };
 	}
+	/**
+	* Move event media between locations — the OPERATOR's mover, no lease.
+	* Twin of `recording.relocateFootage`: same engine (`this.mediaRelocate`)
+	* the lease-gated coordinator move uses, runnable in the background
+	* without pausing anything. `startStorageMigrationMove` above stays
+	* lease-gated for the orchestrated migration; this method must never touch
+	* `storageMigrationLeaseId`.
+	*/
+	async relocateMedia(input) {
+		if (!this.mediaRelocate) throw new Error("media relocation unavailable");
+		const jobId = this.mediaRelocate.start(input);
+		this.ctx.logger.info("pipeline-analytics: media relocate job enqueued", { meta: {
+			jobId,
+			to: input.toLocationId
+		} });
+		return { jobId };
+	}
+	/** Every relocate job this addon knows about, newest first (in RAM: the
+	*  move is resumable, so a lost list costs nothing but the display). */
+	async listRelocateMediaJobs() {
+		return this.mediaRelocate?.list() ?? [];
+	}
+	/** Cancel a running or queued relocate job. */
+	async cancelRelocateMedia(input) {
+		return { cancelled: this.mediaRelocate?.cancel(input.jobId) ?? false };
+	}
 	async listOpsLog(input) {
 		return this.queryFacade.listOpsLog(input);
 	}
@@ -66027,6 +66316,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	}
 	async applyDeviceSettingsPatch(input) {
 		await this.updateDeviceSettings(input.deviceId, input.patch);
+		this.rawDeviceBlobMirror.invalidate(input.deviceId);
 		this.audioSettingsCache.delete(input.deviceId);
 		this.sensitivitySettingsCache.delete(input.deviceId);
 		this.trackingSettingsCache.delete(input.deviceId);

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-Dj-k47_c.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-BZm5TUIO.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.2.127",
+  "version": "1.2.128",
   "description": "Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",