@camstack/addon-pipeline 1.2.119 → 1.2.121

package/dist/recorder/index.mjs

@@ -1,4 +1,4 @@
-import { B as deriveRecordingMode, Dt as hydrateSchema, Gt as string, Ht as number, M as batteryCapability, Pt as selectAssignedProfileSlots, R as deriveBatteryPresence, St as BaseAddon, T as RecordingConfigSchema, Tt as DeviceType, Ut as object, Wt as record, at as recordingCapability, b as OpsLogEntrySchema, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, ft as storageEvictableCapability, g as ExportRecordSchema, gt as errMsg, i as BatteryStatusSchema, jt as nodePin, m as EVENT_PAD_MS, ot as recordingExportCapability, qt as EventCategory, ut as resolveRecordingProfiles, w as RECORDING_EXPORT_MAX_READ_BYTES, wt as DeviceFeature } from "../dist-Db664g2O.mjs";
+import { B as deriveRecordingMode, Dt as hydrateSchema, Gt as string, Ht as number, M as batteryCapability, Pt as selectAssignedProfileSlots, R as deriveBatteryPresence, St as BaseAddon, T as RecordingConfigSchema, Tt as DeviceType, Ut as object, Wt as record, at as recordingCapability, b as OpsLogEntrySchema, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, ft as storageEvictableCapability, g as ExportRecordSchema, gt as errMsg, i as BatteryStatusSchema, jt as nodePin, m as EVENT_PAD_MS, ot as recordingExportCapability, qt as EventCategory, ut as resolveRecordingProfiles, w as RECORDING_EXPORT_MAX_READ_BYTES, wt as DeviceFeature } from "../dist-BJFxSye4.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { r as withRecordingIntent } from "../restream-intent-B4BXZra7.mjs";
 import { n as createFileDataPlaneHandler, s as parseRangeHeader, t as contentTypeFor } from "../addon-utils-CgBCF-mE.mjs";
@@ -538,12 +538,38 @@ function segmentRelPath(deviceId, profile, startMs, durMs, bytes) {
 	return `${deviceId}/${profile}/${d.getUTCFullYear()}/${p2(d.getUTCMonth() + 1)}/${p2(d.getUTCDate())}/${p2(d.getUTCHours())}/${startMs}-${durMs}-${bytes}.m4s`;
 }
 var SEG_RE = /^(\d+)\/([^/]+)\/\d{4}\/\d{2}\/\d{2}\/\d{2}\/(\d+)-(\d+)-(\d+)\.m4s$/;
+/**
+* The profile names the recorder writes. Used ONLY to hand back a shared string
+* instead of a fresh one — never to reject a name.
+*
+* `SEG_RE`'s second group is a slice of the path, so V8 materialises a new
+* string for it on every parse. The whole fleet has three profile names and the
+* index holds one row per segment, so that is one redundant string per segment
+* held for the segment's whole life. Measured on the production shape (17
+* cameras x 2 profiles x 12 days of 10 s segments = 3.53 M rows): 798 MB
+* without this, 717 MB with it — 80.7 MB, 24 B/row, ~10% of the index.
+*
+* A name outside this set falls through to the parsed slice unchanged, so an
+* unrecognised profile is never renamed, never dropped, and costs exactly what
+* it costs today. That fall-through is the property the tests pin.
+*/
+var CANONICAL_PROFILES = [
+	"high",
+	"mid",
+	"low"
+];
+/** The shared instance of `profile` when it is one of {@link CANONICAL_PROFILES},
+*  otherwise `profile` itself. */
+function canonicalProfile(profile) {
+	for (const known of CANONICAL_PROFILES) if (known === profile) return known;
+	return profile;
+}
 function parseSegmentPath(relPath) {
 	const m = SEG_RE.exec(relPath);
 	if (!m) return null;
 	return {
 		deviceId: Number(m[1]),
-		profile: m[2],
+		profile: canonicalProfile(m[2]),
 		startMs: Number(m[3]),
 		durMs: Number(m[4]),
 		bytes: Number(m[5])
@@ -589,6 +615,9 @@ var RecordingIndex = class {
 	sortedByDevice = /* @__PURE__ */ new Map();
 	fullRebuilds = 0;
 	incrementalInserts = 0;
+	/** See {@link HydrateReuseStats}. */
+	rowsReused = 0;
+	rowsAllocated = 0;
 	/** Hour buckets this device has been walked for; `ALL_HOURS` after a full
 	*  hydrate. Empty = nothing has been looked at, which is NOT the same as
 	*  "there is nothing" — see {@link hydrationOf}. */
@@ -627,6 +656,13 @@ var RecordingIndex = class {
 			incrementalInserts: this.incrementalInserts
 		};
 	}
+	/** See {@link HydrateReuseStats}. Cumulative over the process. */
+	hydrateReuseStats() {
+		return {
+			rowsReused: this.rowsReused,
+			rowsAllocated: this.rowsAllocated
+		};
+	}
 	/**
 	* Ordered insert of ONE NEW row into every live view it belongs to (the
 	* all-profiles view and its own profile's view). Views not yet materialised
@@ -644,25 +680,70 @@ var RecordingIndex = class {
 		}
 	}
 	/**
+	* The row to index for `path` at `locationId`, REUSING the held one when the
+	* index already has it.
+	*
+	* ## Why a re-walk must not re-allocate (the second copy of every path)
+	*
+	* Every field of a `SegmentRow` except `locationId` is derived from `path`,
+	* so a held row at the same location is not merely EQUAL to a rebuilt one —
+	* it is the same fact. Rebuilding it allocates a second byte-identical path
+	* string, and that second string does not stay a garbage-collectable
+	* duplicate: `SegmentHourLedger`'s mirror still holds the FIRST one, because
+	* `reconcileFromIndex` skips its `ledger.put` exactly when the contents
+	* match. The archive walk (`roots.ts`) composes a fresh `${deviceId}/${entry}`
+	* for every file it reads, so before this reuse existed the first walk after
+	* every boot doubled the retained path strings of the whole archive,
+	* permanently.
+	*
+	* Measured on the production shape (26 cameras x 2 profiles x 12 days of
+	* 10 s segments = 5.39 M rows): 1218 MB held before the walk, 1591 MB after
+	* — +373 MB, 69 B/row, one extra `SeqOneByteString` per segment.
+	*
+	* Interning the strings instead was measured and is WORSE (+597 MB): the
+	* intern table costs more than the duplicate it removes. Not allocating is
+	* the only cheap answer.
+	*
+	* `null` = not a segment path, or another device's.
+	*/
+	rowFor(held, path, deviceId, locationId) {
+		const prev = held.get(path);
+		if (prev !== void 0 && prev.locationId === locationId) {
+			this.rowsReused += 1;
+			return prev;
+		}
+		const p = parseSegmentPath(path);
+		if (!p || p.deviceId !== deviceId) return null;
+		this.rowsAllocated += 1;
+		return {
+			deviceId: p.deviceId,
+			profile: p.profile,
+			startMs: p.startMs,
+			durMs: p.durMs,
+			bytes: p.bytes,
+			path,
+			locationId
+		};
+	}
+	/**
 	* Replace a device's segments FOR ONE LOCATION from a `storage.list` result (paths relative to that
 	* location root). Rows on other locations are preserved. Non-segment paths and other devices are ignored.
+	*
+	* Deliberately NOT delete-all-then-reinsert: the archive walk re-reports rows
+	* this index already holds, with freshly built path strings, and dropping the
+	* held rows first would make those fresh strings the permanent ones — a
+	* second copy of the whole archive's paths. See {@link retainedPathStrings}.
 	*/
 	hydrateDevice(deviceId, locationId, relPaths) {
 		const m = this.mapFor(deviceId);
-		for (const [path, existing] of m) if (existing.locationId === locationId) m.delete(path);
+		const seen = /* @__PURE__ */ new Set();
 		for (const path of relPaths) {
-			const p = parseSegmentPath(path);
-			if (!p || p.deviceId !== deviceId) continue;
-			m.set(path, {
-				deviceId: p.deviceId,
-				profile: p.profile,
-				startMs: p.startMs,
-				durMs: p.durMs,
-				bytes: p.bytes,
-				path,
-				locationId
-			});
+			const row = this.rowFor(m, path, deviceId, locationId);
+			if (row === null) continue;
+			if (row.path !== path || m.get(path) !== row) m.set(path, row);
+			seen.add(path);
 		}
+		for (const [path, existing] of m) if (existing.locationId === locationId && !seen.has(path)) m.delete(path);
 		this.invalidateSorted(deviceId);
 	}
 	/**
@@ -707,20 +788,15 @@ var RecordingIndex = class {
 	*/
 	hydrateHour(deviceId, locationId, hourStartMs, relPaths) {
 		const m = this.mapFor(deviceId);
+		let changed = false;
 		for (const path of relPaths) {
-			const p = parseSegmentPath(path);
-			if (!p || p.deviceId !== deviceId) continue;
-			m.set(path, {
-				deviceId: p.deviceId,
-				profile: p.profile,
-				startMs: p.startMs,
-				durMs: p.durMs,
-				bytes: p.bytes,
-				path,
-				locationId
-			});
+			const row = this.rowFor(m, path, deviceId, locationId);
+			if (row === null) continue;
+			if (m.get(path) === row) continue;
+			m.set(path, row);
+			changed = true;
 		}
-		this.invalidateSorted(deviceId);
+		if (changed) this.invalidateSorted(deviceId);
 		this.markHydrated(deviceId, hourStartMs, hourStartMs + HOUR_MS$5);
 	}
 	/**
@@ -5846,16 +5922,22 @@ async function hydrateDeviceFromStorage(_api, index, deviceId, locations, logger
 		}
 		for (const location of aliases) if (!pathsByLocation.has(location.id)) pathsByLocation.set(location.id, []);
 		let indexed = 0;
+		const reuseBefore = index.hydrateReuseStats();
 		for (const [locationId, relPaths] of pathsByLocation) {
 			index.hydrateDevice(deviceId, locationId, relPaths);
 			indexed += relPaths.length;
 		}
+		const reuseAfter = index.hydrateReuseStats();
+		const reused = reuseAfter.rowsReused - reuseBefore.rowsReused;
+		const allocated = reuseAfter.rowsAllocated - reuseBefore.rowsAllocated;
 		logger.info("recorder: hydrated a device from one recordings root", {
 			tags: { deviceId },
 			meta: {
 				root,
 				entries: entries.length,
 				indexed,
+				reused,
+				allocated,
 				locationIds: [...pathsByLocation.keys()],
 				walkMs: walkedMs - startedMs,
 				ms: Date.now() - startedMs
@@ -5965,6 +6047,8 @@ async function hydrateWindowFromStorage(index, deviceId, fromMs, toMs, locations
 			continue;
 		}
 		const first = Math.floor(fromMs / HOUR_MS$2) * HOUR_MS$2;
+		const reuseBefore = index.hydrateReuseStats();
+		let hoursRead = 0;
 		for (let hour = first; hour < toMs; hour += HOUR_MS$2) for (const profile of profiles) {
 			const rel = hourDirRelPath(deviceId, profile, hour);
 			let files;
@@ -5973,9 +6057,23 @@ async function hydrateWindowFromStorage(index, deviceId, fromMs, toMs, locations
 			} catch {
 				continue;
 			}
+			hoursRead += 1;
 			index.hydrateHour(deviceId, locationForHydratedProfile(aliases, profile).id, hour, files.filter((f) => f.endsWith(".m4s")).map((f) => `${rel}/${f}`));
 		}
 		index.markHydrated(deviceId, fromMs, toMs);
+		if (hoursRead === 0) continue;
+		const reuseAfter = index.hydrateReuseStats();
+		const reused = reuseAfter.rowsReused - reuseBefore.rowsReused;
+		const allocated = reuseAfter.rowsAllocated - reuseBefore.rowsAllocated;
+		logger.info("recorder: hydrated a window from one recordings root", {
+			tags: { deviceId },
+			meta: {
+				root,
+				hoursRead,
+				reused,
+				allocated
+			}
+		});
 	}
 }
 //#endregion