@camstack/addon-pipeline 1.2.194 → 1.2.196

package/dist/pipeline-runner/index.js

@@ -5156,12 +5156,6 @@ var PipelineRunner = class {
 		return null;
 	}
 };
-/**
-* How much of a region must lie OUTSIDE every full-frame detection for the
-* pass to run on it. A person's own blob (dilated, with shadow) is covered
-* 70–90% by the person box; a person-and-dog blob is covered ~55% by it.
-*/
-var RECOVERY_MIN_UNCOVERED_FRACTION = .35;
 function area(r) {
 	return Math.max(0, r.w) * Math.max(0, r.h);
 }
@@ -5209,25 +5203,53 @@ function cropsForRegion(region, native) {
 	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
 }
 /**
-* The crops the second pass runs on this frame — possibly none.
+* The ONE place the two region gates are decided. `planRecoveryCrops` filters
+* on it and {@link countRecoverySkips} counts it, so the report can never
+* describe a gate the planner does not actually apply.
+*/
+function classifyRegion(region, uncovered) {
+	if (area(region) > .25) return "too-large";
+	if (uncovered < .35) return "covered";
+	return "eligible";
+}
+/**
+* WHY A FRAME PLANNED NO CROP, AS A NUMBER (D378).
 *
-* A region qualifies when it is small (`RECOVERY_MAX_REGION_FRAME_FRACTION`)
-* and mostly uncovered by the full-frame boxes
-* (`RECOVERY_MIN_UNCOVERED_FRACTION`). Qualifying regions are served largest
-* uncovered area first under `RECOVERY_MAX_CROPS_PER_FRAME`; a crop whose
-* centre already lies inside a planned crop is folded into it. A frame that
-* cannot hold the smallest crop yields nothing: it is already seen at scale.
+* The pass report counts the passes that RAN, so "the second pass stops running
+* when a person is beside the dog" — a plausible reading of
+* {@link RECOVERY_MAX_REGION_FRAME_FRACTION} and
+* {@link RECOVERY_MIN_UNCOVERED_FRACTION}, and a live hypothesis on camera 615
+* — could not be confirmed or killed from the logs at all. This classifies the
+* regions a frame offered, against the same predicate the planner filters on.
 */
+function countRecoverySkips(input) {
+	let tooLarge = 0;
+	let covered = 0;
+	let eligible = 0;
+	for (const region of input.regions) switch (classifyRegion(region, uncoveredFraction(region, input.detections))) {
+		case "too-large":
+			tooLarge += 1;
+			break;
+		case "covered":
+			covered += 1;
+			break;
+		case "eligible":
+			eligible += 1;
+			break;
+	}
+	return {
+		tooLarge,
+		covered,
+		eligible
+	};
+}
 function planRecoveryCrops(input) {
 	const { native } = input;
 	if (Math.min(native.width, native.height) < 640) return [];
 	const ranked = input.regions.map((region) => ({
 		region,
 		uncovered: uncoveredFraction(region, input.detections)
-	})).filter(({ region, uncovered }) => {
-		if (area(region) > .25) return false;
-		return uncovered >= RECOVERY_MIN_UNCOVERED_FRACTION;
-	}).toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
+	})).filter(({ region, uncovered }) => classifyRegion(region, uncovered) === "eligible").toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
 	const planned = [];
 	for (const { region } of ranked) for (const crop of cropsForRegion(region, native)) {
 		if (planned.length >= 2) return planned;
@@ -5258,6 +5280,11 @@ function remapCropDetections(detections, crop, view, result, native) {
 		if (x <= 2 || y <= 2 || x + width >= view.width - 2 || y + height >= view.height - 2) continue;
 		out.push({
 			...detection,
+			nativeRecovery: {
+				score: detection.score,
+				cropSidePx: crop.side,
+				viewPx: view.width
+			},
 			bbox: {
 				x: (crop.left + x * viewToNative) * nativeToResultX,
 				y: (crop.top + y * viewToNative) * nativeToResultY,
@@ -5922,6 +5949,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	/** Per-camera counters since the last recovery report line. */
 	recoveryStats = /* @__PURE__ */ new Map();
 	/**
+	* Per-camera counters for the frames on which the pass did NOT run, since the
+	* last report line (D378). "The second pass stops running when a person is
+	* beside the dog" was a live hypothesis on camera 615 and the logs could not
+	* answer it: a report that counts only the passes that ran cannot say why the
+	* others did not. `rateLimited` is the cadence cap, `noMotion` an empty or
+	* stale motion mirror, and `tooLarge` / `covered` the two region gates.
+	*/
+	recoverySkips = /* @__PURE__ */ new Map();
+	/**
 	* Gates the root-plane `package-detection` step to motion-settle edges +
 	* a low-cadence safety poll instead of every frame (packages are
 	* stationary — per-frame parcel inference is wasted cost). Consulted in
@@ -7645,6 +7681,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.motionRegions.forget(deviceId);
 		this.lastRecoveryAt.delete(deviceId);
 		this.recoveryStats.delete(deviceId);
+		this.recoverySkips.delete(deviceId);
 		const warnPrefix = `${deviceId}:`;
 		for (const key of this.warnedNoJumpDevice) if (key.startsWith(warnPrefix)) this.warnedNoJumpDevice.delete(key);
 		this.attached.delete(deviceId);
@@ -8413,9 +8450,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		const api = this.ctx?.api;
 		if (!api || !frame.frameRef) return result;
 		const now = Date.now();
-		if (now - (this.lastRecoveryAt.get(deviceId) ?? 0) < 500) return result;
+		if (now - (this.lastRecoveryAt.get(deviceId) ?? 0) < 500) {
+			this.addRecoverySkips(deviceId, { rateLimited: 1 });
+			return result;
+		}
 		const regions = this.motionRegions.fresh(deviceId, now);
-		if (regions.length === 0) return result;
+		if (regions.length === 0) {
+			this.addRecoverySkips(deviceId, { noMotion: 1 });
+			return result;
+		}
 		const step = selectRecoveryStep(steps);
 		if (step === null) return result;
 		if (result.width <= 0 || result.height <= 0) return result;
@@ -8423,7 +8466,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			width: frame.frameRef.width,
 			height: frame.frameRef.height
 		};
-		const crops = planRecoveryCrops({
+		const planInput = {
 			regions,
 			detections: result.detections.filter((d) => d.kind === "first-level").map((d) => ({
 				x: d.bbox.x / result.width,
@@ -8432,8 +8475,16 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				h: d.bbox.height / result.height
 			})),
 			native
-		});
-		if (crops.length === 0) return result;
+		};
+		const crops = planRecoveryCrops(planInput);
+		if (crops.length === 0) {
+			const skipped = countRecoverySkips(planInput);
+			this.addRecoverySkips(deviceId, {
+				tooLarge: skipped.tooLarge,
+				covered: skipped.covered
+			});
+			return result;
+		}
 		this.lastRecoveryAt.set(deviceId, now);
 		const log = this.ctx.logger.withTags({ deviceId });
 		const started = Date.now();
@@ -8473,7 +8524,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			recovered: added,
 			ms: Date.now() - started,
 			now,
-			classes: fused.slice(result.detections.length).map((d) => d.macroClass)
+			classes: fused.slice(result.detections.length).map((d) => `${d.macroClass}:${d.score.toFixed(3)}`)
 		});
 		return added > 0 ? {
 			...result,
@@ -8522,6 +8573,26 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			lease.release(reason);
 		}
 	}
+	/**
+	* Fold a frame's non-run into the per-camera skip counters, drained by the
+	* next report line (D378). Counters, never lines: a skip happens several
+	* times a second per camera and a line per skip would be the noisiest thing
+	* in the log.
+	*/
+	addRecoverySkips(deviceId, delta) {
+		const current = this.recoverySkips.get(deviceId) ?? {
+			rateLimited: 0,
+			noMotion: 0,
+			tooLarge: 0,
+			covered: 0
+		};
+		this.recoverySkips.set(deviceId, {
+			rateLimited: current.rateLimited + (delta.rateLimited ?? 0),
+			noMotion: current.noMotion + (delta.noMotion ?? 0),
+			tooLarge: current.tooLarge + (delta.tooLarge ?? 0),
+			covered: current.covered + (delta.covered ?? 0)
+		});
+	}
 	/** Aggregate the pass per camera and report once per {@link RECOVERY_LOG_INTERVAL_MS}. */
 	reportRecovery(deviceId, sample) {
 		const stats = this.recoveryStats.get(deviceId) ?? {
@@ -8548,6 +8619,12 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			}
 		});
 		if (sample.now - stats.reportedAt >= RECOVERY_LOG_INTERVAL_MS) {
+			const skips = this.recoverySkips.get(deviceId) ?? {
+				rateLimited: 0,
+				noMotion: 0,
+				tooLarge: 0,
+				covered: 0
+			};
 			this.ctx.logger.info("small-subject recovery: pass report", {
 				tags: { deviceId },
 				meta: {
@@ -8555,9 +8632,14 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 					crops: next.crops,
 					recovered: next.recovered,
 					avgMsPerPass: next.passes > 0 ? Math.round(next.ms / next.passes) : 0,
-					windowMs: sample.now - stats.reportedAt
+					windowMs: sample.now - stats.reportedAt,
+					skipRateLimited: skips.rateLimited,
+					skipNoMotion: skips.noMotion,
+					skipTooLarge: skips.tooLarge,
+					skipCovered: skips.covered
 				}
 			});
+			this.recoverySkips.delete(deviceId);
 			this.recoveryStats.set(deviceId, {
 				passes: 0,
 				crops: 0,

package/dist/pipeline-runner/index.mjs

@@ -5149,12 +5149,6 @@ var PipelineRunner = class {
 		return null;
 	}
 };
-/**
-* How much of a region must lie OUTSIDE every full-frame detection for the
-* pass to run on it. A person's own blob (dilated, with shadow) is covered
-* 70–90% by the person box; a person-and-dog blob is covered ~55% by it.
-*/
-var RECOVERY_MIN_UNCOVERED_FRACTION = .35;
 function area(r) {
 	return Math.max(0, r.w) * Math.max(0, r.h);
 }
@@ -5202,25 +5196,53 @@ function cropsForRegion(region, native) {
 	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
 }
 /**
-* The crops the second pass runs on this frame — possibly none.
+* The ONE place the two region gates are decided. `planRecoveryCrops` filters
+* on it and {@link countRecoverySkips} counts it, so the report can never
+* describe a gate the planner does not actually apply.
+*/
+function classifyRegion(region, uncovered) {
+	if (area(region) > .25) return "too-large";
+	if (uncovered < .35) return "covered";
+	return "eligible";
+}
+/**
+* WHY A FRAME PLANNED NO CROP, AS A NUMBER (D378).
 *
-* A region qualifies when it is small (`RECOVERY_MAX_REGION_FRAME_FRACTION`)
-* and mostly uncovered by the full-frame boxes
-* (`RECOVERY_MIN_UNCOVERED_FRACTION`). Qualifying regions are served largest
-* uncovered area first under `RECOVERY_MAX_CROPS_PER_FRAME`; a crop whose
-* centre already lies inside a planned crop is folded into it. A frame that
-* cannot hold the smallest crop yields nothing: it is already seen at scale.
+* The pass report counts the passes that RAN, so "the second pass stops running
+* when a person is beside the dog" — a plausible reading of
+* {@link RECOVERY_MAX_REGION_FRAME_FRACTION} and
+* {@link RECOVERY_MIN_UNCOVERED_FRACTION}, and a live hypothesis on camera 615
+* — could not be confirmed or killed from the logs at all. This classifies the
+* regions a frame offered, against the same predicate the planner filters on.
 */
+function countRecoverySkips(input) {
+	let tooLarge = 0;
+	let covered = 0;
+	let eligible = 0;
+	for (const region of input.regions) switch (classifyRegion(region, uncoveredFraction(region, input.detections))) {
+		case "too-large":
+			tooLarge += 1;
+			break;
+		case "covered":
+			covered += 1;
+			break;
+		case "eligible":
+			eligible += 1;
+			break;
+	}
+	return {
+		tooLarge,
+		covered,
+		eligible
+	};
+}
 function planRecoveryCrops(input) {
 	const { native } = input;
 	if (Math.min(native.width, native.height) < 640) return [];
 	const ranked = input.regions.map((region) => ({
 		region,
 		uncovered: uncoveredFraction(region, input.detections)
-	})).filter(({ region, uncovered }) => {
-		if (area(region) > .25) return false;
-		return uncovered >= RECOVERY_MIN_UNCOVERED_FRACTION;
-	}).toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
+	})).filter(({ region, uncovered }) => classifyRegion(region, uncovered) === "eligible").toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
 	const planned = [];
 	for (const { region } of ranked) for (const crop of cropsForRegion(region, native)) {
 		if (planned.length >= 2) return planned;
@@ -5251,6 +5273,11 @@ function remapCropDetections(detections, crop, view, result, native) {
 		if (x <= 2 || y <= 2 || x + width >= view.width - 2 || y + height >= view.height - 2) continue;
 		out.push({
 			...detection,
+			nativeRecovery: {
+				score: detection.score,
+				cropSidePx: crop.side,
+				viewPx: view.width
+			},
 			bbox: {
 				x: (crop.left + x * viewToNative) * nativeToResultX,
 				y: (crop.top + y * viewToNative) * nativeToResultY,
@@ -5915,6 +5942,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 	/** Per-camera counters since the last recovery report line. */
 	recoveryStats = /* @__PURE__ */ new Map();
 	/**
+	* Per-camera counters for the frames on which the pass did NOT run, since the
+	* last report line (D378). "The second pass stops running when a person is
+	* beside the dog" was a live hypothesis on camera 615 and the logs could not
+	* answer it: a report that counts only the passes that ran cannot say why the
+	* others did not. `rateLimited` is the cadence cap, `noMotion` an empty or
+	* stale motion mirror, and `tooLarge` / `covered` the two region gates.
+	*/
+	recoverySkips = /* @__PURE__ */ new Map();
+	/**
 	* Gates the root-plane `package-detection` step to motion-settle edges +
 	* a low-cadence safety poll instead of every frame (packages are
 	* stationary — per-frame parcel inference is wasted cost). Consulted in
@@ -7638,6 +7674,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 		this.motionRegions.forget(deviceId);
 		this.lastRecoveryAt.delete(deviceId);
 		this.recoveryStats.delete(deviceId);
+		this.recoverySkips.delete(deviceId);
 		const warnPrefix = `${deviceId}:`;
 		for (const key of this.warnedNoJumpDevice) if (key.startsWith(warnPrefix)) this.warnedNoJumpDevice.delete(key);
 		this.attached.delete(deviceId);
@@ -8406,9 +8443,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 		const api = this.ctx?.api;
 		if (!api || !frame.frameRef) return result;
 		const now = Date.now();
-		if (now - (this.lastRecoveryAt.get(deviceId) ?? 0) < 500) return result;
+		if (now - (this.lastRecoveryAt.get(deviceId) ?? 0) < 500) {
+			this.addRecoverySkips(deviceId, { rateLimited: 1 });
+			return result;
+		}
 		const regions = this.motionRegions.fresh(deviceId, now);
-		if (regions.length === 0) return result;
+		if (regions.length === 0) {
+			this.addRecoverySkips(deviceId, { noMotion: 1 });
+			return result;
+		}
 		const step = selectRecoveryStep(steps);
 		if (step === null) return result;
 		if (result.width <= 0 || result.height <= 0) return result;
@@ -8416,7 +8459,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 			width: frame.frameRef.width,
 			height: frame.frameRef.height
 		};
-		const crops = planRecoveryCrops({
+		const planInput = {
 			regions,
 			detections: result.detections.filter((d) => d.kind === "first-level").map((d) => ({
 				x: d.bbox.x / result.width,
@@ -8425,8 +8468,16 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 				h: d.bbox.height / result.height
 			})),
 			native
-		});
-		if (crops.length === 0) return result;
+		};
+		const crops = planRecoveryCrops(planInput);
+		if (crops.length === 0) {
+			const skipped = countRecoverySkips(planInput);
+			this.addRecoverySkips(deviceId, {
+				tooLarge: skipped.tooLarge,
+				covered: skipped.covered
+			});
+			return result;
+		}
 		this.lastRecoveryAt.set(deviceId, now);
 		const log = this.ctx.logger.withTags({ deviceId });
 		const started = Date.now();
@@ -8466,7 +8517,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 			recovered: added,
 			ms: Date.now() - started,
 			now,
-			classes: fused.slice(result.detections.length).map((d) => d.macroClass)
+			classes: fused.slice(result.detections.length).map((d) => `${d.macroClass}:${d.score.toFixed(3)}`)
 		});
 		return added > 0 ? {
 			...result,
@@ -8515,6 +8566,26 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 			lease.release(reason);
 		}
 	}
+	/**
+	* Fold a frame's non-run into the per-camera skip counters, drained by the
+	* next report line (D378). Counters, never lines: a skip happens several
+	* times a second per camera and a line per skip would be the noisiest thing
+	* in the log.
+	*/
+	addRecoverySkips(deviceId, delta) {
+		const current = this.recoverySkips.get(deviceId) ?? {
+			rateLimited: 0,
+			noMotion: 0,
+			tooLarge: 0,
+			covered: 0
+		};
+		this.recoverySkips.set(deviceId, {
+			rateLimited: current.rateLimited + (delta.rateLimited ?? 0),
+			noMotion: current.noMotion + (delta.noMotion ?? 0),
+			tooLarge: current.tooLarge + (delta.tooLarge ?? 0),
+			covered: current.covered + (delta.covered ?? 0)
+		});
+	}
 	/** Aggregate the pass per camera and report once per {@link RECOVERY_LOG_INTERVAL_MS}. */
 	reportRecovery(deviceId, sample) {
 		const stats = this.recoveryStats.get(deviceId) ?? {
@@ -8541,6 +8612,12 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 			}
 		});
 		if (sample.now - stats.reportedAt >= RECOVERY_LOG_INTERVAL_MS) {
+			const skips = this.recoverySkips.get(deviceId) ?? {
+				rateLimited: 0,
+				noMotion: 0,
+				tooLarge: 0,
+				covered: 0
+			};
 			this.ctx.logger.info("small-subject recovery: pass report", {
 				tags: { deviceId },
 				meta: {
@@ -8548,9 +8625,14 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 					crops: next.crops,
 					recovered: next.recovered,
 					avgMsPerPass: next.passes > 0 ? Math.round(next.ms / next.passes) : 0,
-					windowMs: sample.now - stats.reportedAt
+					windowMs: sample.now - stats.reportedAt,
+					skipRateLimited: skips.rateLimited,
+					skipNoMotion: skips.noMotion,
+					skipTooLarge: skips.tooLarge,
+					skipCovered: skips.covered
 				}
 			});
+			this.recoverySkips.delete(deviceId);
 			this.recoveryStats.set(deviceId, {
 				passes: 0,
 				crops: 0,

package/dist/stream-broker/{_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-C6K2j4VN.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BMsB2MVD.mjs}

@@ -3,7 +3,7 @@ import "./dist-CYZr2fwk.mjs";
 var e = {
 	"@camstack/sdk": {
 		name: "@camstack/sdk",
-		version: "1.2.76",
+		version: "1.2.78",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",
@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.156",
+		version: "1.2.158",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",
@@ -33,7 +33,7 @@ var e = {
 	},
 	"@camstack/ui-library": {
 		name: "@camstack/ui-library",
-		version: "1.2.124",
+		version: "1.2.126",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",

package/dist/stream-broker/{hostInit-cpmZf09I.mjs → hostInit-CZig_taJ.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.156",
+				version: "1.2.158",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -45,7 +45,7 @@ async function r() {
 				}
 			},
 			"@camstack/sdk": {
-				version: "1.2.76",
+				version: "1.2.78",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.124",
+				version: "1.2.126",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

package/dist/stream-broker/index.js

@@ -24079,6 +24079,79 @@ var ScrubFragmentCache = class {
 		return this.map.size;
 	}
 };
+//#endregion
+//#region src/stream-broker/recorded/segment-pts-repair.ts
+function median(values) {
+	const sorted = values.toSorted((a, b) => a - b);
+	const mid = sorted.length >> 1;
+	if (sorted.length % 2 === 1) return sorted[mid] ?? 0;
+	return ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
+}
+function untouched(aus, read) {
+	const first = aus[0];
+	const last = aus[aus.length - 1];
+	const span = first !== void 0 && last !== void 0 ? read(last) - read(first) : 0;
+	return {
+		aus,
+		repaired: false,
+		discontinuities: 0,
+		collapsedMs: 0,
+		spanBeforeMs: span,
+		spanAfterMs: span
+	};
+}
+/**
+* Rewrite the stamps of `aus` so no inter-AU gap exceeds `durMs`, the window
+* the recorder measured for this segment.
+*
+* Returns the INPUT array unchanged (same identity, so a healthy segment costs
+* nothing) when there is nothing to repair, when there are fewer than two units
+* to compare, or when `durMs` is not a usable window — with no declared window
+* there is no authority to judge a gap against, and inventing one would be
+* worse than pacing what the file says.
+*/
+function repairSegmentPts(aus, durMs, read, write) {
+	if (aus.length < 2 || !Number.isFinite(durMs) || durMs <= 0) return untouched(aus, read);
+	const gaps = [];
+	let faults = 0;
+	for (let i = 1; i < aus.length; i++) {
+		const prev = aus[i - 1];
+		const cur = aus[i];
+		if (prev === void 0 || cur === void 0) return untouched(aus, read);
+		const gap = read(cur) - read(prev);
+		gaps.push(gap);
+		if (gap > durMs) faults++;
+	}
+	if (faults === 0) return untouched(aus, read);
+	const healthy = gaps.filter((g) => g <= durMs);
+	const cadenceMs = healthy.length > 0 ? median(healthy) : durMs / gaps.length;
+	const first = aus[0];
+	if (first === void 0) return untouched(aus, read);
+	const repaired = [first];
+	let shiftMs = 0;
+	let collapsedMs = 0;
+	for (let i = 1; i < aus.length; i++) {
+		const au = aus[i];
+		if (au === void 0) return untouched(aus, read);
+		const gap = gaps[i - 1] ?? 0;
+		if (gap > durMs) {
+			const removed = gap - cadenceMs;
+			shiftMs += removed;
+			collapsedMs += removed;
+		}
+		repaired.push(write(au, read(au) - shiftMs));
+	}
+	const lastIn = aus[aus.length - 1];
+	const lastOut = repaired[repaired.length - 1];
+	return {
+		aus: repaired,
+		repaired: true,
+		discontinuities: faults,
+		collapsedMs,
+		spanBeforeMs: lastIn === void 0 ? 0 : read(lastIn) - read(first),
+		spanAfterMs: lastOut === void 0 ? 0 : read(lastOut) - read(first)
+	};
+}
 /**
 * `velocity` is ms of timeline per ms of wall clock, signed. `readMs` is what a
 * read costs on this disk right now. Either being null means "not enough is
@@ -24161,6 +24234,13 @@ var PLAY_CENSUS_INTERVAL_TICKS = 5;
 */
 var PLAY_STALL_MS = 50;
 /**
+* How many distinct segment starts a feeder remembers having reported as
+* PTS-repaired, so a camera writing broken stamps names each damaged segment
+* once instead of once per scrub warm. Cleared wholesale when full — the set is
+* a log de-duplicator, not state anything reads.
+*/
+var PTS_REPAIR_LOG_MEMORY = 64;
+/**
 * Upper bound on a single inter-frame sleep. Frame gaps at 10–30 fps are
 * 33–100 ms, so this rarely splits a real wait; it exists so an unusually long
 * PTS gap (or an empty/tail wait) still re-checks the abort guards promptly,
@@ -24612,6 +24692,8 @@ var RecordedFeeder = class {
 	* that is the bottleneck and the census would look calm.
 	*/
 	scrubPrefetched = /* @__PURE__ */ new Set();
+	/** Segment starts already reported by {@link repairPts} — see the docblock. */
+	ptsRepairLogged = /* @__PURE__ */ new Set();
 	/** Recent read durations — the evidence speculation is suspended on. */
 	scrubReadMsWindow = [];
 	/** Warm-up runs once per drag, from the playhead the finger went down on. */
@@ -24916,7 +24998,7 @@ var RecordedFeeder = class {
 					bytes: reusedWhole.bytes.byteLength
 				};
 			} else {
-				const fullLoad = this.loadAus(loc.startMs, this.rate !== 0, this.deps.readGop ? void 0 : (video) => {
+				const fullLoad = this.loadAus(loc.startMs, loc.durMs, this.rate !== 0, this.deps.readGop ? void 0 : (video) => {
 					if (this.disposed || token !== this.seekToken) return;
 					this.feedPrefix(loc, video, landMs);
 					prefixFed = true;
@@ -25872,8 +25954,9 @@ var RecordedFeeder = class {
 			}));
 			const readEndMs = performance.now();
 			if (this.disposed || token !== this.seekToken) return null;
-			const aus = await this.withTimeout(this.deps.demux(gop.bytes));
+			const demuxed = await this.withTimeout(this.deps.demux(gop.bytes));
 			if (this.disposed || token !== this.seekToken) return null;
+			const aus = this.repairPts(demuxed, gop.gopStartMs, gop.gopDurMs);
 			this.noteScrubReadMs(readEndMs - readStartMs);
 			return {
 				seg: {
@@ -25896,8 +25979,9 @@ var RecordedFeeder = class {
 		}));
 		const readEndMs = performance.now();
 		if (this.disposed || token !== this.seekToken) return null;
-		const aus = await this.withTimeout(this.deps.demux(bytes));
+		const demuxedWhole = await this.withTimeout(this.deps.demux(bytes));
 		if (this.disposed || token !== this.seekToken) return null;
+		const aus = this.repairPts(demuxedWhole, loc.startMs, loc.durMs);
 		this.noteScrubReadMs(readEndMs - readStartMs);
 		return {
 			seg: {
@@ -26280,7 +26364,7 @@ var RecordedFeeder = class {
 			if (this.disposed || token !== this.seekToken || this.rate !== 0) return;
 		}
 		if (loc.kind !== "segment" || loc.startMs >= seg.startMs) return;
-		const loaded = await this.loadAus(loc.startMs, false);
+		const loaded = await this.loadAus(loc.startMs, loc.durMs, false);
 		if (loaded === null || loaded.video.length === 0) return;
 		if (this.disposed || this.rate !== 0) return;
 		this.currentSegment = {
@@ -26544,7 +26628,7 @@ var RecordedFeeder = class {
 				probe = loc.startMs + loc.durMs + 1;
 				continue;
 			}
-			const loaded = await this.loadAus(loc.startMs);
+			const loaded = await this.loadAus(loc.startMs, loc.durMs);
 			if (loaded === null) return null;
 			return {
 				startMs: loc.startMs,
@@ -26563,7 +26647,7 @@ var RecordedFeeder = class {
 	*  (latest-wins). Returns null on abort. Audio demux failures yield [] (audio
 	*  never blocks video). `wantAudio: false` skips the audio transcode entirely
 	*  (paused scrubs would throw it away). */
-	async loadAus(startMs, wantAudio = true, onVideoReady) {
+	async loadAus(startMs, durMs, wantAudio = true, onVideoReady) {
 		const token = this.seekToken;
 		const readStartedAt = performance.now();
 		const bytes = await this.withTimeout(this.deps.readBytes({
@@ -26575,7 +26659,8 @@ var RecordedFeeder = class {
 		if (this.disposed || token !== this.seekToken) return null;
 		const demuxStartedAt = performance.now();
 		const audioPromise = wantAudio && this.deps.demuxAudio && this.resolveAudioPush() !== void 0 ? this.withTimeout(this.deps.demuxAudio(bytes)).catch(() => []) : Promise.resolve([]);
-		const videoPromise = this.withTimeout(this.deps.demux(bytes)).then((video) => {
+		const videoPromise = this.withTimeout(this.deps.demux(bytes)).then((demuxed) => {
+			const video = this.repairPts(demuxed, startMs, durMs);
 			if (!this.disposed && token === this.seekToken) onVideoReady?.(video);
 			return video;
 		});
@@ -26590,6 +26675,44 @@ var RecordedFeeder = class {
 			bytes: bytes.byteLength
 		};
 	}
+	/**
+	* Make one demuxed series fit the window the recorder measured for it, and
+	* SAY SO when it did not — see `segment-pts-repair.ts` for why a gap wider
+	* than `durMs` cannot be footage.
+	*
+	* This is the only guard between the file's stamps and `paceSegment`, which
+	* sleeps every inter-AU delta out with no bound. Device 4374's segments put
+	* their key frame 73 s before the frame after it inside a 9 955 ms window;
+	* the loop slept, the cursor never moved off the seek target, and the only
+	* evidence was a `recorded:play-census` line with `pacedAus=150 segments=1`.
+	* A branch that silently drops work logs (repo rule) — and the log carries
+	* `deviceId` through `onLog`'s tags, because "why is 4374 worse than 615" is
+	* the only way this question is ever asked.
+	*
+	* Logged once per segment start per feeder: a broken camera should name every
+	* distinct segment it damages, not repeat one on every scrub warm.
+	*/
+	repairPts(aus, startMs, durMs) {
+		const result = repairSegmentPts(aus, durMs, (au) => au.ptsMs, (au, ptsMs) => ({
+			...au,
+			ptsMs
+		}));
+		if (!result.repaired) return aus;
+		if (!this.ptsRepairLogged.has(startMs)) {
+			if (this.ptsRepairLogged.size >= PTS_REPAIR_LOG_MEMORY) this.ptsRepairLogged.clear();
+			this.ptsRepairLogged.add(startMs);
+			this.deps.onLog?.("recorded:segment-pts-repaired", {
+				startMs,
+				durMs,
+				aus: aus.length,
+				discontinuities: result.discontinuities,
+				collapsedMs: Math.round(result.collapsedMs),
+				spanBeforeMs: Math.round(result.spanBeforeMs),
+				spanAfterMs: Math.round(result.spanAfterMs)
+			});
+		}
+		return [...result.aus];
+	}
 	startPositionReports() {
 		if (this.positionTimer) return;
 		this.positionTicks = 0;

package/dist/stream-broker/index.mjs

@@ -24076,6 +24076,79 @@ var ScrubFragmentCache = class {
 		return this.map.size;
 	}
 };
+//#endregion
+//#region src/stream-broker/recorded/segment-pts-repair.ts
+function median(values) {
+	const sorted = values.toSorted((a, b) => a - b);
+	const mid = sorted.length >> 1;
+	if (sorted.length % 2 === 1) return sorted[mid] ?? 0;
+	return ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2;
+}
+function untouched(aus, read) {
+	const first = aus[0];
+	const last = aus[aus.length - 1];
+	const span = first !== void 0 && last !== void 0 ? read(last) - read(first) : 0;
+	return {
+		aus,
+		repaired: false,
+		discontinuities: 0,
+		collapsedMs: 0,
+		spanBeforeMs: span,
+		spanAfterMs: span
+	};
+}
+/**
+* Rewrite the stamps of `aus` so no inter-AU gap exceeds `durMs`, the window
+* the recorder measured for this segment.
+*
+* Returns the INPUT array unchanged (same identity, so a healthy segment costs
+* nothing) when there is nothing to repair, when there are fewer than two units
+* to compare, or when `durMs` is not a usable window — with no declared window
+* there is no authority to judge a gap against, and inventing one would be
+* worse than pacing what the file says.
+*/
+function repairSegmentPts(aus, durMs, read, write) {
+	if (aus.length < 2 || !Number.isFinite(durMs) || durMs <= 0) return untouched(aus, read);
+	const gaps = [];
+	let faults = 0;
+	for (let i = 1; i < aus.length; i++) {
+		const prev = aus[i - 1];
+		const cur = aus[i];
+		if (prev === void 0 || cur === void 0) return untouched(aus, read);
+		const gap = read(cur) - read(prev);
+		gaps.push(gap);
+		if (gap > durMs) faults++;
+	}
+	if (faults === 0) return untouched(aus, read);
+	const healthy = gaps.filter((g) => g <= durMs);
+	const cadenceMs = healthy.length > 0 ? median(healthy) : durMs / gaps.length;
+	const first = aus[0];
+	if (first === void 0) return untouched(aus, read);
+	const repaired = [first];
+	let shiftMs = 0;
+	let collapsedMs = 0;
+	for (let i = 1; i < aus.length; i++) {
+		const au = aus[i];
+		if (au === void 0) return untouched(aus, read);
+		const gap = gaps[i - 1] ?? 0;
+		if (gap > durMs) {
+			const removed = gap - cadenceMs;
+			shiftMs += removed;
+			collapsedMs += removed;
+		}
+		repaired.push(write(au, read(au) - shiftMs));
+	}
+	const lastIn = aus[aus.length - 1];
+	const lastOut = repaired[repaired.length - 1];
+	return {
+		aus: repaired,
+		repaired: true,
+		discontinuities: faults,
+		collapsedMs,
+		spanBeforeMs: lastIn === void 0 ? 0 : read(lastIn) - read(first),
+		spanAfterMs: lastOut === void 0 ? 0 : read(lastOut) - read(first)
+	};
+}
 /**
 * `velocity` is ms of timeline per ms of wall clock, signed. `readMs` is what a
 * read costs on this disk right now. Either being null means "not enough is
@@ -24158,6 +24231,13 @@ var PLAY_CENSUS_INTERVAL_TICKS = 5;
 */
 var PLAY_STALL_MS = 50;
 /**
+* How many distinct segment starts a feeder remembers having reported as
+* PTS-repaired, so a camera writing broken stamps names each damaged segment
+* once instead of once per scrub warm. Cleared wholesale when full — the set is
+* a log de-duplicator, not state anything reads.
+*/
+var PTS_REPAIR_LOG_MEMORY = 64;
+/**
 * Upper bound on a single inter-frame sleep. Frame gaps at 10–30 fps are
 * 33–100 ms, so this rarely splits a real wait; it exists so an unusually long
 * PTS gap (or an empty/tail wait) still re-checks the abort guards promptly,
@@ -24609,6 +24689,8 @@ var RecordedFeeder = class {
 	* that is the bottleneck and the census would look calm.
 	*/
 	scrubPrefetched = /* @__PURE__ */ new Set();
+	/** Segment starts already reported by {@link repairPts} — see the docblock. */
+	ptsRepairLogged = /* @__PURE__ */ new Set();
 	/** Recent read durations — the evidence speculation is suspended on. */
 	scrubReadMsWindow = [];
 	/** Warm-up runs once per drag, from the playhead the finger went down on. */
@@ -24913,7 +24995,7 @@ var RecordedFeeder = class {
 					bytes: reusedWhole.bytes.byteLength
 				};
 			} else {
-				const fullLoad = this.loadAus(loc.startMs, this.rate !== 0, this.deps.readGop ? void 0 : (video) => {
+				const fullLoad = this.loadAus(loc.startMs, loc.durMs, this.rate !== 0, this.deps.readGop ? void 0 : (video) => {
 					if (this.disposed || token !== this.seekToken) return;
 					this.feedPrefix(loc, video, landMs);
 					prefixFed = true;
@@ -25869,8 +25951,9 @@ var RecordedFeeder = class {
 			}));
 			const readEndMs = performance.now();
 			if (this.disposed || token !== this.seekToken) return null;
-			const aus = await this.withTimeout(this.deps.demux(gop.bytes));
+			const demuxed = await this.withTimeout(this.deps.demux(gop.bytes));
 			if (this.disposed || token !== this.seekToken) return null;
+			const aus = this.repairPts(demuxed, gop.gopStartMs, gop.gopDurMs);
 			this.noteScrubReadMs(readEndMs - readStartMs);
 			return {
 				seg: {
@@ -25893,8 +25976,9 @@ var RecordedFeeder = class {
 		}));
 		const readEndMs = performance.now();
 		if (this.disposed || token !== this.seekToken) return null;
-		const aus = await this.withTimeout(this.deps.demux(bytes));
+		const demuxedWhole = await this.withTimeout(this.deps.demux(bytes));
 		if (this.disposed || token !== this.seekToken) return null;
+		const aus = this.repairPts(demuxedWhole, loc.startMs, loc.durMs);
 		this.noteScrubReadMs(readEndMs - readStartMs);
 		return {
 			seg: {
@@ -26277,7 +26361,7 @@ var RecordedFeeder = class {
 			if (this.disposed || token !== this.seekToken || this.rate !== 0) return;
 		}
 		if (loc.kind !== "segment" || loc.startMs >= seg.startMs) return;
-		const loaded = await this.loadAus(loc.startMs, false);
+		const loaded = await this.loadAus(loc.startMs, loc.durMs, false);
 		if (loaded === null || loaded.video.length === 0) return;
 		if (this.disposed || this.rate !== 0) return;
 		this.currentSegment = {
@@ -26541,7 +26625,7 @@ var RecordedFeeder = class {
 				probe = loc.startMs + loc.durMs + 1;
 				continue;
 			}
-			const loaded = await this.loadAus(loc.startMs);
+			const loaded = await this.loadAus(loc.startMs, loc.durMs);
 			if (loaded === null) return null;
 			return {
 				startMs: loc.startMs,
@@ -26560,7 +26644,7 @@ var RecordedFeeder = class {
 	*  (latest-wins). Returns null on abort. Audio demux failures yield [] (audio
 	*  never blocks video). `wantAudio: false` skips the audio transcode entirely
 	*  (paused scrubs would throw it away). */
-	async loadAus(startMs, wantAudio = true, onVideoReady) {
+	async loadAus(startMs, durMs, wantAudio = true, onVideoReady) {
 		const token = this.seekToken;
 		const readStartedAt = performance.now();
 		const bytes = await this.withTimeout(this.deps.readBytes({
@@ -26572,7 +26656,8 @@ var RecordedFeeder = class {
 		if (this.disposed || token !== this.seekToken) return null;
 		const demuxStartedAt = performance.now();
 		const audioPromise = wantAudio && this.deps.demuxAudio && this.resolveAudioPush() !== void 0 ? this.withTimeout(this.deps.demuxAudio(bytes)).catch(() => []) : Promise.resolve([]);
-		const videoPromise = this.withTimeout(this.deps.demux(bytes)).then((video) => {
+		const videoPromise = this.withTimeout(this.deps.demux(bytes)).then((demuxed) => {
+			const video = this.repairPts(demuxed, startMs, durMs);
 			if (!this.disposed && token === this.seekToken) onVideoReady?.(video);
 			return video;
 		});
@@ -26587,6 +26672,44 @@ var RecordedFeeder = class {
 			bytes: bytes.byteLength
 		};
 	}
+	/**
+	* Make one demuxed series fit the window the recorder measured for it, and
+	* SAY SO when it did not — see `segment-pts-repair.ts` for why a gap wider
+	* than `durMs` cannot be footage.
+	*
+	* This is the only guard between the file's stamps and `paceSegment`, which
+	* sleeps every inter-AU delta out with no bound. Device 4374's segments put
+	* their key frame 73 s before the frame after it inside a 9 955 ms window;
+	* the loop slept, the cursor never moved off the seek target, and the only
+	* evidence was a `recorded:play-census` line with `pacedAus=150 segments=1`.
+	* A branch that silently drops work logs (repo rule) — and the log carries
+	* `deviceId` through `onLog`'s tags, because "why is 4374 worse than 615" is
+	* the only way this question is ever asked.
+	*
+	* Logged once per segment start per feeder: a broken camera should name every
+	* distinct segment it damages, not repeat one on every scrub warm.
+	*/
+	repairPts(aus, startMs, durMs) {
+		const result = repairSegmentPts(aus, durMs, (au) => au.ptsMs, (au, ptsMs) => ({
+			...au,
+			ptsMs
+		}));
+		if (!result.repaired) return aus;
+		if (!this.ptsRepairLogged.has(startMs)) {
+			if (this.ptsRepairLogged.size >= PTS_REPAIR_LOG_MEMORY) this.ptsRepairLogged.clear();
+			this.ptsRepairLogged.add(startMs);
+			this.deps.onLog?.("recorded:segment-pts-repaired", {
+				startMs,
+				durMs,
+				aus: aus.length,
+				discontinuities: result.discontinuities,
+				collapsedMs: Math.round(result.collapsedMs),
+				spanBeforeMs: Math.round(result.spanBeforeMs),
+				spanAfterMs: Math.round(result.spanAfterMs)
+			});
+		}
+		return [...result.aus];
+	}
 	startPositionReports() {
 		if (this.positionTimer) return;
 		this.positionTicks = 0;

package/dist/stream-broker/remoteEntry.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.194",
+  "version": "1.2.196",
   "description": "Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",