@camstack/addon-post-analysis 1.2.266 → 1.2.268

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as TimelapseRuleSchema, $t as array, A as NcConditionDescriptorSchema, At as readDeviceStateFrom, B as NcTaxonomySchema, Bt as zoneAnalyticsCapability, C as MOTION_CLOSE_AFTER_MS, Ct as mayWriteToLocation, D as NC_DEFAULT_SNOOZE_MINUTES, Dt as pickClusterStepModels, E as NC_CONDITION_CATALOG, F as NcScheduleSchema, Ft as storageOccupancyCapability, Gt as createEvent, Ht as BaseAddon, I as NcSnoozeInputSchema, It as subKindsOf, J as SCENE_DIVERGED, Jt as hydrateSchema, K as SCENE_DEFAULT_ANCHOR_THRESHOLD, Kt as customAction, L as NcSnoozeSchema, Lt as systemEventFilterApplies, M as NcRulePatchSchema, Mt as resolveLocationMode, N as NcRuleSchema, Ot as pipelineAnalyticsCapability, P as NcRuleTargetSchema, Pt as sceneMonitorCapability, Q as TimelapseRulePatchSchema, Qt as _enum, R as NcSnoozeSuppressedSchema, Rt as vectorDimFromBase64, St as kebabToCamel, T as NC_ALARM_SYSTEM_EVENT_KINDS, Tt as occupancyScope, U as RECORDING_EXPORT_MAX_READ_BYTES, Ut as CamProfileSchema, V as OpsLogEntrySchema, Vt as errMsg$1, W as RetrainStatusSchema, Wt as DeviceType, X as TIMELAPSE_DENSE_FLOOR_SEC, Xt as nodePin, Y as SceneMonitorSchema, Yt as isDeviceScopedCap, Z as TimelapseRuleInputSchema, Zt as sleep$1, _ as FULL_IMAGE_BBOX, _t as isDetectionMacroClass, a as CLUSTER_MODEL_SCOPED_STEPS, an as partialRecord, at as audioMetricsCapability, b as MAX_ARCHIVED_DEBUG_NOTES, bt as isScheduleActive, cn as unknown, ct as cosineSimilarity$1, dt as encodeVectorBase64, en as boolean, et as TrackSourceSchema, f as DeclaredDevices, ft as evaluateSensorEdge, g as FIRST_LEVEL_MACRO_CLASSES, h as EVENT_PAD_MS, ht as failureContributionCapability, i as BirthDecisionRecordSchema, in as object, it as assertTimelapseCadences, j as NcRuleInputSchema, jt as readTimelapseGeneratedAt, k as NC_TAXONOMY, kt as plateGalleryCapability, ln as EventCategory, lt as deriveRecordingMode, m as EVENT_OWNER_TYPES, mt as faceGalleryCapability, n as ArchivedDebugNoteSchema, nn as literal, nt as addonWidgetsSourceCapability, o as COCO_TO_MACRO, on as record, ot as audioModeOf, p as EVENT_KIND_BY_CAP, pt as evictionPolicyOfLocation, q as SCENE_DEFAULT_UNCOVERED_POLICY, qt as defineCustomActions, r as BaseDevice, rn as number, rt as alarmPanelCapability, s as DEFAULT_EVENT_COLOR, sn as string, st as buildEventKindDescriptor, t as AUDIO_MACRO_LABELS, tn as discriminatedUnion, tt as VISIT_MERGE_GAP_MS, u as DETECTION_MACRO_CLASSES, v as FailureCounters, vt as isEventOwnerType, w as MediaFileKindEnum, wt as notificationRulesCapability, x as MAX_BIRTH_DECISION_RECORDS, xt as isSourceCap, y as LabelAttributionSchema, yt as isMediaOwnerType, z as NcSystemEventKindSchema, zt as videoclipsCapability } from "../dist-CxMzr0uA.mjs";
+import { $ as TimelapseRuleSchema, $t as array, A as NcConditionDescriptorSchema, At as readDeviceStateFrom, B as NcTaxonomySchema, Bt as zoneAnalyticsCapability, C as MOTION_CLOSE_AFTER_MS, Ct as mayWriteToLocation, D as NC_DEFAULT_SNOOZE_MINUTES, Dt as pickClusterStepModels, E as NC_CONDITION_CATALOG, F as NcScheduleSchema, Ft as storageOccupancyCapability, Gt as createEvent, Ht as BaseAddon, I as NcSnoozeInputSchema, It as subKindsOf, J as SCENE_DIVERGED, Jt as hydrateSchema, K as SCENE_DEFAULT_ANCHOR_THRESHOLD, Kt as customAction, L as NcSnoozeSchema, Lt as systemEventFilterApplies, M as NcRulePatchSchema, Mt as resolveLocationMode, N as NcRuleSchema, Ot as pipelineAnalyticsCapability, P as NcRuleTargetSchema, Pt as sceneMonitorCapability, Q as TimelapseRulePatchSchema, Qt as _enum, R as NcSnoozeSuppressedSchema, Rt as vectorDimFromBase64, St as kebabToCamel, T as NC_ALARM_SYSTEM_EVENT_KINDS, Tt as occupancyScope, U as RECORDING_EXPORT_MAX_READ_BYTES, Ut as CamProfileSchema, V as OpsLogEntrySchema, Vt as errMsg$1, W as RetrainStatusSchema, Wt as DeviceType, X as TIMELAPSE_DENSE_FLOOR_SEC, Xt as nodePin, Y as SceneMonitorSchema, Yt as isDeviceScopedCap, Z as TimelapseRuleInputSchema, Zt as sleep$1, _ as FULL_IMAGE_BBOX, _t as isDetectionMacroClass, a as CLUSTER_MODEL_SCOPED_STEPS, an as partialRecord, at as audioMetricsCapability, b as MAX_ARCHIVED_DEBUG_NOTES, bt as isScheduleActive, cn as unknown, ct as cosineSimilarity$1, dt as encodeVectorBase64, en as boolean, et as TrackSourceSchema, f as DeclaredDevices, ft as evaluateSensorEdge, g as FIRST_LEVEL_MACRO_CLASSES, h as EVENT_PAD_MS, ht as failureContributionCapability, i as BirthDecisionRecordSchema, in as object, it as assertTimelapseCadences, j as NcRuleInputSchema, jt as readTimelapseGeneratedAt, k as NC_TAXONOMY, kt as plateGalleryCapability, ln as EventCategory, lt as deriveRecordingMode, m as EVENT_OWNER_TYPES, mt as faceGalleryCapability, n as ArchivedDebugNoteSchema, nn as literal, nt as addonWidgetsSourceCapability, o as COCO_TO_MACRO, on as record, ot as audioModeOf, p as EVENT_KIND_BY_CAP, pt as evictionPolicyOfLocation, q as SCENE_DEFAULT_UNCOVERED_POLICY, qt as defineCustomActions, r as BaseDevice, rn as number, rt as alarmPanelCapability, s as DEFAULT_EVENT_COLOR, sn as string, st as buildEventKindDescriptor, t as AUDIO_MACRO_LABELS, tn as discriminatedUnion, tt as VISIT_MERGE_GAP_MS, u as DETECTION_MACRO_CLASSES, v as FailureCounters, vt as isEventOwnerType, w as MediaFileKindEnum, wt as notificationRulesCapability, x as MAX_BIRTH_DECISION_RECORDS, xt as isSourceCap, y as LabelAttributionSchema, yt as isMediaOwnerType, z as NcSystemEventKindSchema, zt as videoclipsCapability } from "../dist-DO_99QlZ.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs from "node:fs";
 import { promises } from "node:fs";
@@ -37210,6 +37210,11 @@ var SortTracker = class SortTracker {
 	* three call sites reach and only one of them could have been handed it.
 	*/
 	frameArea = 0;
+	/** The frame DIMS of the pass, for the same reason `frameArea` is held: the
+	*  salvage-bind record carries both boxes, and a box without the frame it was
+	*  measured in cannot be put back on a picture. `0` = no frame context. */
+	frameWidthPx = 0;
+	frameHeightPx = 0;
 	/** Sink for track deaths — see {@link setTrackLossObserver}. */
 	trackLossObserver = null;
 	trackLossSampler = new TrackLossSampler();
@@ -37447,6 +37452,20 @@ var SortTracker = class SortTracker {
 			centroidDistPx: Math.hypot(tc.x - dc.x, tc.y - dc.y),
 			trackDiagPx: Math.hypot(track.bbox.w, track.bbox.h),
 			areaRatio: smaller > 0 ? Math.max(trackArea, detArea) / smaller : 0,
+			trackBbox: {
+				x: track.bbox.x,
+				y: track.bbox.y,
+				w: track.bbox.w,
+				h: track.bbox.h
+			},
+			detBbox: {
+				x: det.bbox.x,
+				y: det.bbox.y,
+				w: det.bbox.w,
+				h: det.bbox.h
+			},
+			frameWidth: this.frameWidthPx,
+			frameHeight: this.frameHeightPx,
 			dtMs: timestamp - track.lastSeen,
 			trackAgeMs: timestamp - track.firstSeen,
 			bindCount,
@@ -37991,6 +38010,8 @@ var SortTracker = class SortTracker {
 		this.frameSeq++;
 		const frameArea = frameContext ? frameContext.frameWidth * frameContext.frameHeight : 0;
 		this.frameArea = frameArea;
+		this.frameWidthPx = frameContext?.frameWidth ?? 0;
+		this.frameHeightPx = frameContext?.frameHeight ?? 0;
 		const continuationOnly = frameContext?.continuationOnly ?? EMPTY_INDEX_SET;
 		const resurrectedScene = /* @__PURE__ */ new Map();
 		if (this.config.maxTrackLifetimeMs > 0) {
@@ -38338,7 +38359,7 @@ var StateAnalyzer = class {
 			}
 			const velocity = track.velocity ? Math.sqrt(track.velocity.dx ** 2 + track.velocity.dy ** 2) : 0;
 			const dwellTimeMs = timestamp - ts.enteredAt;
-			const settled = velocity <= this.config.velocityThreshold || this.windowSaysStill(ts, track.bbox, timestamp);
+			const settled = this.speedSaysSettled(ts, track.bbox, velocity) || this.windowSaysStill(ts, track.bbox, timestamp);
 			let state;
 			if (ts.frameCount <= this.config.enteringFrames) state = "entering";
 			else if (settled) {
@@ -38374,6 +38395,37 @@ var StateAnalyzer = class {
 		return results;
 	}
 	/**
+	* The SPEED half of the settled test.
+	*
+	* Uncalibrated (`stillSpeedFracPerSec` undefined) this is the original line
+	* verbatim — the tracker's px-per-update velocity against the flat
+	* `velocityThreshold`. Nothing about an uncalibrated camera changes.
+	*
+	* Calibrated, the same question is asked in the camera's own units: how far
+	* the centroid moved between the last two OBSERVED samples, over the
+	* subject's own box diagonal, over the elapsed SECONDS. Per second and not
+	* per update because these cameras are `armed:on-motion` and deliver a
+	* settle burst plus a poll — 56 ms to 2135 ms between stored positions on
+	* one subject (D399) — so a per-update figure says more about the cadence
+	* than about the subject.
+	*
+	* An interval that cannot be measured (a single sample, a non-positive
+	* elapsed time, a box with no size) is UNKNOWN, and unknown never reads as
+	* settled. A track that young is still inside `enteringFrames` anyway.
+	*/
+	speedSaysSettled(ts, bbox, velocity) {
+		const bar = this.config.stillSpeedFracPerSec;
+		if (bar === void 0) return velocity <= this.config.velocityThreshold;
+		const last = ts.recent[ts.recent.length - 1];
+		const prev = ts.recent[ts.recent.length - 2];
+		if (!last || !prev) return false;
+		const elapsedSec = (last.at - prev.at) / 1e3;
+		if (!(elapsedSec > 0)) return false;
+		const diagonal = Math.hypot(bbox.w, bbox.h);
+		if (!(diagonal > 0)) return false;
+		return Math.hypot(last.x - prev.x, last.y - prev.y) / diagonal / elapsedSec <= bar;
+	}
+	/**
 	* Whether the centroid has stayed inside a small span for the whole window.
 	*
 	* The span is measured across the samples themselves (their bounding box),
@@ -41235,6 +41287,17 @@ var TrackResidentState = class {
 	objectEmbeddingBestSelector = new TrackBestSelector(BEST_OBJECT_EMBED_POLICY);
 	/** keyFrame keys of CLOSED tracks still readable until the recognizer-end
 	*  deferred drop settles (see module docstring). */
+	/**
+	* How many LIVE tracks carry the operator's `debug` flag, across every camera
+	* this runner holds.
+	*
+	* A counter rather than a scan because the frame path asks it every frame:
+	* it is what lets the host skip maintaining a per-frame handle mirror
+	* entirely while nothing is marked, which is the state of the fleet
+	* essentially always. Kept in step in the three places a resident's flag can
+	* change: {@link setDebugMarked}, {@link close} and {@link clearAll}.
+	*/
+	debugMarkedCount = 0;
 	deferredKeyFrameKeys = /* @__PURE__ */ new Map();
 	constructor(hooks = {}) {
 		this.hooks = hooks;
@@ -41256,7 +41319,8 @@ var TrackResidentState = class {
 			thumbnailLanded: false,
 			keyFrameLanded: false,
 			keyFrameRetries: 0,
-			confirmed: false
+			confirmed: false,
+			debugMarked: false
 		};
 		this.residents.set(trackId, created);
 		return created;
@@ -41270,6 +41334,7 @@ var TrackResidentState = class {
 	*/
 	close(trackId, mode) {
 		const resident = this.residents.get(trackId);
+		if (resident?.debugMarked === true) this.debugMarkedCount -= 1;
 		this.residents.delete(trackId);
 		this.bestFrameTracker.delete(trackId);
 		this.objectEmbeddingBestSelector.delete(trackId);
@@ -41289,6 +41354,7 @@ var TrackResidentState = class {
 	}
 	/** Drop everything (addon dispose). */
 	clearAll() {
+		this.debugMarkedCount = 0;
 		this.residents.clear();
 		this.bestFrameTracker.clear();
 		this.objectEmbeddingBestSelector.clear();
@@ -41480,6 +41546,42 @@ var TrackResidentState = class {
 	markConfirmed(deviceId, trackId) {
 		this.ensure(deviceId, trackId).confirmed = true;
 	}
+	/**
+	* Is this track the one the operator is asking about?
+	*
+	* THE gate for every debug crop, and it must stay this cheap: one map lookup,
+	* no store read, no allocation. An unknown track is not marked — a lookup
+	* that finds nothing is the common case on every camera in the fleet.
+	*/
+	isDebugMarked(trackId) {
+		return this.residents.get(trackId)?.debugMarked ?? false;
+	}
+	/**
+	* Record the operator's `debug` flag for a LIVE track.
+	*
+	* Called from the `setTrackFlags` cap mutation, which is the only thing that
+	* can turn the flag on — so this runs once per press, not per frame.
+	* `ensure` rather than a lookup: the button can be pressed on a track whose
+	* first frame is still in flight, and a mark that silently missed would be
+	* the operator clicking and getting nothing, which is the whole complaint.
+	*/
+	setDebugMarked(deviceId, trackId, marked) {
+		const resident = this.ensure(deviceId, trackId);
+		if (resident.debugMarked === marked) return;
+		resident.debugMarked = marked;
+		this.debugMarkedCount += marked ? 1 : -1;
+	}
+	/**
+	* Does ANY live track on this runner carry the flag?
+	*
+	* The frame path's own gate, one level above {@link isDebugMarked}: it lets
+	* the host skip the per-frame bookkeeping a debug crop needs (the frame
+	* handle mirror the salvage-bind observer reads) while nothing is marked —
+	* which is the fleet's normal state. A counter read, no scan, no allocation.
+	*/
+	anyDebugMarked() {
+		return this.debugMarkedCount > 0;
+	}
 	/** Retain the FIRST detection-raster crop per track (zero-media fallback);
 	*  a later frame never overwrites an existing one. */
 	retainRasterFallback(deviceId, trackId, fallback) {
@@ -47983,6 +48085,336 @@ function makeViewerSettingsActionHandlers(store) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/stillness-calibration-actions.ts
+/**
+* stillness-calibration-actions — "measure this camera's own stillness scale".
+*
+* ## Why an `addons.custom` action and not a cap method
+*
+* Same reason as `face.rescoreTrack` beside it: a cap method's wire schema
+* lives in `@camstack/types`, which travels inside the `@camstack/server`
+* closure, so a new one is not callable until a server train ships. Here the
+* schema lives in this addon's own dist and the hub forwards an opaque
+* envelope, so `camstack deploy` is the whole delivery.
+*
+* ## Why `apply` is explicit and not a fallback
+*
+* A calibration run READS recorded tracks and does arithmetic. Applying it
+* WRITES the camera's settings and changes what the tracker calls settled from
+* the next frame on. Those are different enough in consequence that a button
+* labelled "calibrate" must not choose between them on the operator's behalf —
+* the run reports, the operator applies. A REFUSED run never writes the bar
+* whatever `apply` says; it writes only the note, so the refusal and its reason
+* are visible in the form instead of being a toast that scrolls away.
+*/
+/** Mirrors `StillnessCalibrationRefusal` — kept literal so the wire schema is
+*  self-describing and a new reason is a deliberate edit in both places. */
+var StillnessRefusalSchema = _enum([
+	"no-tracks",
+	"too-few-tracks",
+	"too-few-samples",
+	"no-motion-evidence"
+]);
+var StillnessMeasurementSchema = object({
+	/** Tracks that contributed at least one speed sample. */
+	trackCount: number().int(),
+	/** Tracks the pass actually read, after the cost bound. */
+	tracksRead: number().int(),
+	sampleCount: number().int(),
+	/** Speed quantiles, subject-box-diagonals per second. `null` when there was
+	*  nothing to measure — never 0, which would read as a measured stillness
+	*  (D393). */
+	p25: number().nullable(),
+	p50: number().nullable(),
+	p90: number().nullable(),
+	/** Median gap between stored positions (s) — the camera's real cadence. */
+	medianIntervalSec: number().nullable(),
+	/** Median subject box diagonal (px) the speeds were normalised by. */
+	medianSubjectDiagonalPx: number().nullable()
+});
+var stillnessCalibrationActions = defineCustomActions({ 
+/**
+* `admin` because it WRITES a per-camera detection threshold when `apply` is
+* set, and because the report describes how the camera's subjects move,
+* which is not a viewer-level fact.
+*/
+"stillness.calibrate": customAction(object({
+	deviceId: number().int(),
+	/** How far back to read. Bounded: this pass parses ~10 kB of trajectory a
+	*  row, so the window is a suggestion and `maxTracks` is the real bound. */
+	sinceHours: number().min(.25).max(720).default(72),
+	/** Hard cost bound on tracks read, newest first. */
+	maxTracks: number().int().min(1).max(1e3).default(200),
+	/**
+	* Write the chosen bar onto the camera. Never implicit, and never done at
+	* all for a refused run.
+	*/
+	apply: boolean().default(false)
+}), object({
+	deviceId: number().int(),
+	/** The window actually read (epoch ms). */
+	since: number().int(),
+	until: number().int(),
+	accepted: boolean(),
+	/** Why it refused. Absent on an accepted run. */
+	reason: StillnessRefusalSchema.optional(),
+	/** The chosen bar, subject-box-diagonals per second. Absent on a refusal —
+	*  never 0, which the settings layer reads as "uncalibrated". */
+	bar: number().optional(),
+	/** The raw quantile before the rails, so the clamp is arguable. */
+	rawBar: number().optional(),
+	clampedBy: _enum([
+		"none",
+		"floor",
+		"ceiling",
+		"min",
+		"max"
+	]).optional(),
+	measurement: StillnessMeasurementSchema,
+	/** The bar this camera was on BEFORE the run — `null` = uncalibrated. Read
+	*  before any write, so the operator sees both numbers. */
+	previousBar: number().nullable(),
+	/** Whether the camera's settings were actually written. */
+	applied: boolean(),
+	/** The one-line note stored on the camera (accepted or refused). */
+	note: string()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}) });
+/**
+* The shipped limits.
+*
+* `minTracks` 12 / `minSamples` 200: the four live cameras sampled above
+* produced 697–8739 samples from 42–51 tracks in a single 60-track read, so a
+* camera that cannot clear these has genuinely not been watched enough.
+* `maxTracks` 200 bounds the read: the `positions` blob averages ~10 kB a row
+* (`track-store.ts`), so this pass is ~2 MB of JSON at its worst.
+*/
+var DEFAULT_STILLNESS_CALIBRATION_LIMITS = {
+	minTracks: 12,
+	minSamples: 200,
+	maxTracks: 200,
+	minIntervalSec: .02,
+	maxIntervalSec: 3,
+	quantile: .25,
+	floorFactor: .02,
+	ceilFactor: .25,
+	minBar: .001,
+	maxBar: 1
+};
+/** Linear-interpolated quantile. `NaN` for an empty list — never 0, which
+*  would read as a measured zero (D393). */
+function quantileOf(values, p) {
+	if (values.length === 0) return NaN;
+	const sorted = [...values].sort((a, b) => a - b);
+	const idx = (sorted.length - 1) * Math.min(Math.max(p, 0), 1);
+	const lo = Math.floor(idx);
+	const hi = Math.ceil(idx);
+	const at = sorted[lo];
+	const next = sorted[hi];
+	if (at === void 0 || next === void 0) return NaN;
+	return at + (next - at) * (idx - lo);
+}
+/**
+* Per-sample centroid speeds for a camera, in subject-box-diagonals per second.
+*
+* A pair of consecutive positions contributes a sample only when the interval
+* between them is inside `[minIntervalSec, maxIntervalSec]` and the later box
+* has a positive diagonal. A gap outside that band is a session boundary or a
+* duplicate read, not a measurement of how fast anything travelled; a box with
+* no size is unknown geometry, and unknown is never a sample.
+*/
+function collectStillnessSamples(tracks, limits) {
+	const speeds = [];
+	const intervals = [];
+	const diagonals = [];
+	let trackCount = 0;
+	const read = tracks.slice(0, limits.maxTracks);
+	for (const track of read) {
+		const positions = [...track.positions].sort((a, b) => a.timestamp - b.timestamp);
+		let contributed = false;
+		for (let i = 1; i < positions.length; i++) {
+			const prev = positions[i - 1];
+			const cur = positions[i];
+			if (prev === void 0 || cur === void 0) continue;
+			const dtSec = (cur.timestamp - prev.timestamp) / 1e3;
+			if (dtSec < limits.minIntervalSec || dtSec > limits.maxIntervalSec) continue;
+			const diagonal = Math.hypot(cur.bbox.w, cur.bbox.h);
+			if (!(diagonal > 0)) continue;
+			const travelled = Math.hypot(cur.x - prev.x, cur.y - prev.y);
+			speeds.push(travelled / diagonal / dtSec);
+			intervals.push(dtSec);
+			diagonals.push(diagonal);
+			contributed = true;
+		}
+		if (contributed) trackCount++;
+	}
+	return {
+		speeds,
+		intervals,
+		diagonals,
+		trackCount,
+		tracksRead: read.length
+	};
+}
+function measure$1(samples) {
+	return {
+		trackCount: samples.trackCount,
+		sampleCount: samples.speeds.length,
+		p25: quantileOf(samples.speeds, .25),
+		p50: quantileOf(samples.speeds, .5),
+		p90: quantileOf(samples.speeds, .9),
+		medianIntervalSec: quantileOf(samples.intervals, .5),
+		medianSubjectDiagonalPx: quantileOf(samples.diagonals, .5)
+	};
+}
+/**
+* Choose this camera's stillness speed bar, or refuse with a named reason.
+*
+* The order of the gates is the order of the questions: is there anything at
+* all, is it enough tracks, is it enough samples, and did anything on this
+* camera ever actually move. The last one is not pedantry — the whole method
+* scales the bar against the camera's own travel, so with no travel there is
+* nothing to scale against and the default is the honest answer.
+*/
+function calibrateStillnessSpeed(samples, limits) {
+	const measurement = measure$1(samples);
+	if (samples.tracksRead === 0) return {
+		ok: false,
+		reason: "no-tracks",
+		measurement
+	};
+	if (samples.trackCount < limits.minTracks) return {
+		ok: false,
+		reason: "too-few-tracks",
+		measurement
+	};
+	if (samples.speeds.length < limits.minSamples) return {
+		ok: false,
+		reason: "too-few-samples",
+		measurement
+	};
+	if (!(measurement.p90 > 0)) return {
+		ok: false,
+		reason: "no-motion-evidence",
+		measurement
+	};
+	const rawBar = quantileOf(samples.speeds, limits.quantile);
+	const floor = measurement.p90 * limits.floorFactor;
+	const ceiling = measurement.p90 * limits.ceilFactor;
+	let bar = rawBar;
+	let clampedBy = "none";
+	if (bar < floor) {
+		bar = floor;
+		clampedBy = "floor";
+	} else if (bar > ceiling) {
+		bar = ceiling;
+		clampedBy = "ceiling";
+	}
+	if (bar < limits.minBar) {
+		bar = limits.minBar;
+		clampedBy = "min";
+	} else if (bar > limits.maxBar) {
+		bar = limits.maxBar;
+		clampedBy = "max";
+	}
+	return {
+		ok: true,
+		bar,
+		rawBar,
+		clampedBy,
+		measurement
+	};
+}
+/** One line an operator can read: what was measured, from how much, and what
+*  rule produced the stored number. Kept short — it rides the settings blob. */
+function describeStillnessCalibration(outcome) {
+	const m = outcome.measurement;
+	const n = (v) => Number.isFinite(v) ? v.toFixed(4) : "unknown";
+	const evidence = `${m.sampleCount} samples / ${m.trackCount} tracks, p25 ${n(m.p25)}, p50 ${n(m.p50)}, p90 ${n(m.p90)} subject-diagonals/s`;
+	if (!outcome.ok) return `refused (${outcome.reason}) — ${evidence}`;
+	return `bar ${n(outcome.bar)} (raw ${n(outcome.rawBar)}, clamp ${outcome.clampedBy}) — ${evidence}`;
+}
+//#endregion
+//#region src/pipeline-analytics/stillness-settings.ts
+/**
+* Per-device STILLNESS SCALE — the one number that says how fast a subject on
+* THIS camera has to move before it is travelling.
+*
+* A threshold belongs to whoever GENERATES the event, per device, never baked
+* into a classifier default. The judgement this feeds is
+* `StateAnalyzer.speedSaysSettled`; the measurement behind the number is
+* `pipeline/tracker/stillness-scale.ts`, which also carries the live
+* measurement showing why one number cannot serve a 30 m driveway and a 2 m
+* doorway.
+*
+* Cascade and shape mirror `stationary-settings` / `media-settings`: a
+* per-device override on top of the default, resolved per FIELD, and a parse
+* that never throws on a bad blob.
+*
+* **Absent behaves exactly as today.** The device store is a flat numeric blob
+* with no room for "unset", so the stored form of absent is `0` — and `0` is
+* not a bar anyone could want (it would mean nothing on this camera is ever
+* still) and not a value the calibration can produce (`minBar`). The decision
+* layer never sees it: {@link resolveStillSpeedFracPerSec} maps it to
+* `undefined`, and `undefined` is what leaves `StateAnalyzer` on its original
+* absolute `velocityThreshold` path.
+*/
+var StillnessSettingsSchema = object({
+	/**
+	* The camera's "not travelling" bar: centroid speed as a fraction of the
+	* SUBJECT's own box diagonal, per second. `0` = not calibrated (see above).
+	*
+	* Measured p50 on the live hub 2026-09-19, for scale: 0.0136 (device 592,
+	* close view, mostly parked subjects) to 0.3081 (device 615, far view, only
+	* transits).
+	*/
+	stillnessSpeedFracPerSec: number().min(0).max(1).default(0),
+	/**
+	* When the number above was last CHOSEN — by a calibration run or by the
+	* operator. `0` = never. Purely a readout; nothing gates on it.
+	*/
+	stillnessCalibratedAt: number().int().min(0).default(0),
+	/**
+	* What the last calibration run measured and decided, in one line
+	* (`describeStillnessCalibration`) — including a REFUSAL and its named
+	* reason, because "why is this camera still on the default" has to be
+	* answerable without re-running anything.
+	*/
+	stillnessCalibrationNote: string().max(400).default("")
+});
+var STILLNESS_DEFAULTS = StillnessSettingsSchema.parse({});
+/**
+* Resolve a per-device store blob into typed stillness settings. Unknown or
+* invalid fields fall back to the default for that field — including a bar
+* outside the calibration's own rails, which is refused rather than clamped:
+* a number the calibration could never have produced is not evidence about
+* this camera, and silently bending it into range would present it as if it
+* were.
+*/
+function resolveStillnessSettings(raw) {
+	const pick = (key) => {
+		const parsed = StillnessSettingsSchema.shape[key].safeParse(raw[key]);
+		return parsed.success ? parsed.data : STILLNESS_DEFAULTS[key];
+	};
+	return {
+		stillnessSpeedFracPerSec: pick("stillnessSpeedFracPerSec"),
+		stillnessCalibratedAt: pick("stillnessCalibratedAt"),
+		stillnessCalibrationNote: pick("stillnessCalibrationNote")
+	};
+}
+/**
+* The bar the decision layer gets: a positive, in-rails number, or
+* `undefined` for "this camera is not calibrated — judge it exactly as
+* before". The ONE place the stored-zero convention is interpreted.
+*/
+function resolveStillSpeedFracPerSec(settings) {
+	const bar = settings.stillnessSpeedFracPerSec;
+	if (!(bar >= .001) || bar > 1) return void 0;
+	return bar;
+}
+//#endregion
 //#region src/pipeline-analytics/viewer-settings-legacy-adoption.ts
 /**
 * @durable class=config owner=pipeline-analytics
@@ -48691,6 +49123,298 @@ async function extractCropRaw(frameData, frameWidth, frameHeight, bbox) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/bbox-pad.ts
+/**
+* Pad a normalized bounding box by a fractional amount relative to its own
+* dimensions. All coordinates remain in the [0, 1] unit-square.
+*
+* Formula (before clamping):
+*   newX = x - padding * w
+*   newW = w + 2 * padding * w  (i.e. w * (1 + 2 * padding))
+*   newY = y - padding * h
+*   newH = h + 2 * padding * h
+*
+* padding === 0 is the identity operation. Pure, immutable — always returns a
+* new object.
+*
+* NOTE: clamping SHIFTS, it does not truncate — a window that overflows a
+* bound slides inward and keeps the extent that was asked for, on either side.
+* It shrinks only when the padded window is larger than the frame itself
+* would (e.g. a left-hugging box gains a bit more right-side context). This is
+* acceptable for detection crops (more context, never out of [0,1]); the
+* downstream `extractCrop` clamps to pixel bounds again regardless.
+*/
+function padBbox(bbox, padding) {
+	const rawX = bbox.x - padding * bbox.w;
+	const rawY = bbox.y - padding * bbox.h;
+	const rawW = bbox.w * (1 + 2 * padding);
+	const rawH = bbox.h * (1 + 2 * padding);
+	const w = Math.min(rawW, 1);
+	const h = Math.min(rawH, 1);
+	return {
+		x: Math.min(Math.max(0, rawX), 1 - w),
+		y: Math.min(Math.max(0, rawY), 1 - h),
+		w,
+		h
+	};
+}
+/**
+* Legibility floor: the window's SHORT side is grown until it is at least this
+* fraction of the frame's short side.
+*
+* The 2026-09-18 traces included a 24x18 px subject. At the context ratio alone
+* that is a 72x54 window — and 72x54 source pixels are 72x54 delivered pixels,
+* because nothing in this repo may upscale. Growing the RECTANGLE is the only
+* honest way to make the picture bigger: more real pixels arrive, the subject
+* occupies less of the frame, and its drawn box says which part of it is the
+* subject. 0.18 of 1080 = 194 px, which renders a 24 px subject recognisably in
+* its surroundings.
+*/
+var DEBUG_CROP_MIN_SIDE_FRAC = .18;
+function unionBox(a, b) {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	const right = Math.max(a.x + a.w, b.x + b.w);
+	const bottom = Math.max(a.y + a.h, b.y + b.h);
+	return {
+		x,
+		y,
+		w: right - x,
+		h: bottom - y
+	};
+}
+/**
+* Which borders a box touches, on `edge-clear.ts`'s tolerance band — the SAME
+* band `isEdgeClear` uses, so "clipped" here and "not edge-clear" there can
+* never disagree about one frame.
+*/
+function debugCropClipSides(bbox, frameWidth, frameHeight) {
+	if (frameWidth <= 0 || frameHeight <= 0) return [];
+	const tolX = DEFAULT_EDGE_TOLERANCE * frameWidth;
+	const tolY = DEFAULT_EDGE_TOLERANCE * frameHeight;
+	const sides = [];
+	if (bbox.x <= tolX) sides.push("left");
+	if (bbox.y <= tolY) sides.push("top");
+	if (bbox.x + bbox.w >= frameWidth - tolX) sides.push("right");
+	if (bbox.y + bbox.h >= frameHeight - tolY) sides.push("bottom");
+	return sides;
+}
+/**
+* The ratio that makes `base` reach the legibility floor, or
+* {@link DEBUG_CROP_CONTEXT_RATIO} when it already does.
+*
+* Expressed as a PADDING RATIO rather than as a second rectangle so the window
+* still comes out of one {@link padBbox} call: there is exactly one place in
+* this file where a rectangle is grown, and it is not here.
+*/
+function contextRatioFor(base, frameWidth, frameHeight) {
+	const minSide = DEBUG_CROP_MIN_SIDE_FRAC * Math.min(frameWidth, frameHeight);
+	const ratioFor = (extent) => extent <= 0 ? 1 : (minSide / extent - 1) / 2;
+	const needed = Math.max(ratioFor(base.w), ratioFor(base.h));
+	return Math.max(1, needed);
+}
+/**
+* The one debug-crop rectangle. Pure.
+*
+* A refusal is a VALUE, not a `null`: the caller logs the reason, because a
+* branch that stores nothing and says nothing reads as "never happened".
+*/
+function planDebugCrop(input) {
+	const { frameWidth, frameHeight, subject } = input;
+	if (frameWidth <= 0 || frameHeight <= 0) return {
+		kind: "refused",
+		reason: "degenerate-frame"
+	};
+	if (subject.w <= 0 || subject.h <= 0) return {
+		kind: "refused",
+		reason: "degenerate-subject"
+	};
+	const base = input.rival === void 0 ? subject : unionBox(subject, input.rival);
+	const contextRatio = contextRatioFor(base, frameWidth, frameHeight);
+	const norm = padBbox({
+		x: base.x / frameWidth,
+		y: base.y / frameHeight,
+		w: base.w / frameWidth,
+		h: base.h / frameHeight
+	}, contextRatio);
+	const rect = {
+		x: norm.x * frameWidth,
+		y: norm.y * frameHeight,
+		w: norm.w * frameWidth,
+		h: norm.h * frameHeight
+	};
+	const relative = (role, box) => ({
+		role,
+		x: box.x - rect.x,
+		y: box.y - rect.y,
+		w: box.w,
+		h: box.h
+	});
+	const boxes = input.rival === void 0 ? [relative("subject", subject)] : [relative("subject", subject), relative("rival", input.rival)];
+	return {
+		kind: "plan",
+		decision: input.decision,
+		rect,
+		norm,
+		boxes,
+		contextRatio,
+		floorApplied: contextRatio > 1,
+		clippedSides: debugCropClipSides(subject, frameWidth, frameHeight),
+		subjectCenterNorm: {
+			x: (subject.x + subject.w / 2) / frameWidth,
+			y: (subject.y + subject.h / 2) / frameHeight
+		}
+	};
+}
+function formatRect(rect) {
+	return `${Math.round(rect.x)},${Math.round(rect.y)} ${Math.round(rect.w)}x${Math.round(rect.h)}`;
+}
+/**
+* The attribution bag: the deciding site's evidence FIRST, then the structural
+* facts — so no evidence key can rename the decision, the track or the
+* rectangle the crop belongs to. That ordering is the whole point: a crop whose
+* own label can be overwritten by a caller is back to being unattributable.
+*/
+function debugCropMeta(plan, attribution) {
+	return {
+		...attribution.evidence,
+		decision: attribution.decision,
+		trackId: attribution.trackId,
+		...attribution.rivalTrackId === void 0 ? {} : { rivalTrackId: attribution.rivalTrackId },
+		timestamp: attribution.timestamp,
+		cropRect: formatRect(plan.rect),
+		contextRatio: plan.contextRatio,
+		floorApplied: plan.floorApplied,
+		clippedSides: plan.clippedSides.join("|"),
+		subjectCenter: `${plan.subjectCenterNorm.x.toFixed(3)},${plan.subjectCenterNorm.y.toFixed(3)}`
+	};
+}
+/**
+* The caption burnt into the crop's own pixels.
+*
+* Burnt in, not stored beside it, because a debug crop travels: it is exported,
+* pasted into a note, and looked at months later next to five others. A blob
+* that cannot say what it is, on its own, is the thing that made the last
+* investigation slow — and this store has no column to say it in.
+*/
+function debugCropLabel(plan, attribution) {
+	return `${`${attribution.decision} ${attribution.trackId}`}${attribution.rivalTrackId === void 0 ? "" : ` vs ${attribution.rivalTrackId}`}${plan.clippedSides.length === 0 ? "" : ` clipped:${plan.clippedSides.join("+")}`} ${Object.entries(attribution.evidence).map(([k, v]) => `${k}=${typeof v === "number" ? Math.round(v * 1e3) / 1e3 : String(v)}`).join(" ")}`.trim().slice(0, 160);
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/debug-crop-capture.ts
+/** Stroke colour of the box the decision was ABOUT. */
+var SUBJECT_COLOR = "#00e5ff";
+/** Stroke colour of the box it was weighed AGAINST — a different colour,
+*  because "which one is which" is the first question a two-box crop raises. */
+var RIVAL_COLOR = "#ff9500";
+/** Encode quality: a debug crop is read by a person looking for a defect, so it
+*  is encoded above the timeline-tile default (80) — a JPEG artefact that reads
+*  as a mirror edge would waste the very investigation this exists for. */
+var DEBUG_CROP_QUALITY = 92;
+/** Bound the per-track counters so a long-lived process never leaks them. */
+var MAX_TRACKED_TRACKS = 2e3;
+function createDebugCropCapture(deps) {
+	const storedPerTrack = /* @__PURE__ */ new Map();
+	const cappedAnnounced = /* @__PURE__ */ new Set();
+	const skip = (input, reason, extra) => {
+		deps.logger.info("debug crop not stored", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				reason,
+				decision: input.decision,
+				trackId: input.trackId,
+				timestamp: input.timestamp,
+				...extra
+			}
+		});
+		return null;
+	};
+	return async (input) => {
+		if (!deps.isDebugMarked(input.trackId)) return null;
+		const already = storedPerTrack.get(input.trackId) ?? 0;
+		if (already >= 6) {
+			if (cappedAnnounced.has(input.trackId)) return null;
+			if (cappedAnnounced.size >= MAX_TRACKED_TRACKS) cappedAnnounced.clear();
+			cappedAnnounced.add(input.trackId);
+			return skip(input, "per-track-cap", {
+				stored: already,
+				cap: 6
+			});
+		}
+		const plan = planDebugCrop({
+			decision: input.decision,
+			subject: input.subject,
+			...input.rival === void 0 ? {} : { rival: input.rival },
+			frameWidth: input.frameWidth,
+			frameHeight: input.frameHeight
+		});
+		if (plan.kind === "refused") return skip(input, plan.reason, {});
+		const attribution = {
+			decision: input.decision,
+			trackId: input.trackId,
+			...input.rivalTrackId === void 0 ? {} : { rivalTrackId: input.rivalTrackId },
+			timestamp: input.timestamp,
+			evidence: input.evidence
+		};
+		const meta = debugCropMeta(plan, attribution);
+		const frame = await deps.fetchFrameRgb(input.frameHandle, input.deviceId, input.trackId);
+		if (frame === null || frame.width <= 0 || frame.height <= 0) return skip(input, "frame-unavailable", { nodeId: input.frameHandle.nodeId });
+		let jpeg;
+		try {
+			const cut = await deps.extractCropRaw(frame.bytes, frame.width, frame.height, plan.norm);
+			const scale = plan.rect.w > 0 ? cut.width / plan.rect.w : 1;
+			const boxes = plan.boxes.map((b) => {
+				const geometry = {
+					x: b.x * scale,
+					y: b.y * scale,
+					w: b.w * scale,
+					h: b.h * scale
+				};
+				return b.role === "subject" ? {
+					...geometry,
+					color: SUBJECT_COLOR,
+					label: debugCropLabel(plan, attribution)
+				} : {
+					...geometry,
+					color: RIVAL_COLOR,
+					label: "rival"
+				};
+			});
+			jpeg = await deps.drawBoxedFrame(cut.data, cut.width, cut.height, boxes, { quality: DEBUG_CROP_QUALITY });
+		} catch (err) {
+			return skip(input, "render-failed", { error: err instanceof Error ? err.message : String(err) });
+		}
+		try {
+			const mediaId = await deps.putDebugCrop({
+				deviceId: input.deviceId,
+				trackId: input.trackId,
+				timestamp: input.timestamp,
+				data: jpeg
+			});
+			if (storedPerTrack.size >= MAX_TRACKED_TRACKS) storedPerTrack.clear();
+			storedPerTrack.set(input.trackId, already + 1);
+			deps.logger.info("debug crop stored", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					...meta,
+					mediaId,
+					deviceId: input.deviceId
+				}
+			});
+			return mediaId;
+		} catch (err) {
+			deps.logger.warn("debug crop store failed", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					...meta,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+			return null;
+		}
+	};
+}
+//#endregion
 //#region src/shared/frame/encode-crop.ts
 /**
 * JPEG-encode an already-cropped raw RGB (24-bit) buffer. Used for the
@@ -53482,42 +54206,6 @@ var AnalyticsFailureReport = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/pipeline/bbox-pad.ts
-/**
-* Pad a normalized bounding box by a fractional amount relative to its own
-* dimensions. All coordinates remain in the [0, 1] unit-square.
-*
-* Formula (before clamping):
-*   newX = x - padding * w
-*   newW = w + 2 * padding * w  (i.e. w * (1 + 2 * padding))
-*   newY = y - padding * h
-*   newH = h + 2 * padding * h
-*
-* padding === 0 is the identity operation. Pure, immutable — always returns a
-* new object.
-*
-* NOTE: clamping SHIFTS, it does not truncate — a window that overflows a
-* bound slides inward and keeps the extent that was asked for, on either side.
-* It shrinks only when the padded window is larger than the frame itself
-* would (e.g. a left-hugging box gains a bit more right-side context). This is
-* acceptable for detection crops (more context, never out of [0,1]); the
-* downstream `extractCrop` clamps to pixel bounds again regardless.
-*/
-function padBbox(bbox, padding) {
-	const rawX = bbox.x - padding * bbox.w;
-	const rawY = bbox.y - padding * bbox.h;
-	const rawW = bbox.w * (1 + 2 * padding);
-	const rawH = bbox.h * (1 + 2 * padding);
-	const w = Math.min(rawW, 1);
-	const h = Math.min(rawH, 1);
-	return {
-		x: Math.min(Math.max(0, rawX), 1 - w),
-		y: Math.min(Math.max(0, rawY), 1 - h),
-		w,
-		h
-	};
-}
-//#endregion
 //#region src/pipeline-analytics/pipeline/capture-crop.ts
 /**
 * The normalised window a capture asks the runner for: the box padded by
@@ -71343,6 +72031,56 @@ var SyntheticTrackMaterializer = class {
 		return track;
 	}
 };
+//#endregion
+//#region src/pipeline-analytics/stationary-settings.ts
+/**
+* Per-device stationary-object (parked/idle suppression) settings. Cascade: a
+* per-device override on top of the global default, resolved per field (an
+* invalid/missing value falls back to its default — parse never throws).
+* Mirrors `media-settings` / `tracking-settings`.
+*
+* The defaults are the SAME constants the registry uses at runtime
+* (`stationary-types.ts`), imported (not copied) so an unset value and a reset
+* value both resolve to exactly today's behaviour — "reset == unset == today",
+* with no drift. Guarded by a unit test asserting the equality.
+*/
+var StationarySettingsSchema = object({
+	/** Master switch. Off ⇒ this camera gathers no evidence and suppresses
+	*  nothing (every parked object keeps spawning normal tracks). */
+	enabled: boolean().default(true),
+	/** IoU at/above which a detection is the same parked object, unmoved →
+	*  suppress its spawn. `SUPPRESS_IOU`. */
+	suppressIou: number().min(.3).max(.9).default(SUPPRESS_IOU),
+	/** Minimum IoU for a detection to be ASSOCIATED with an entry (confirm or
+	*  wake it) — the overlap gate that stops a different vehicle from waking a
+	*  parked entry (the 617 flood fix). `WAKE_ASSOC_IOU`. */
+	wakeAssocIou: number().min(.02).max(.5).default(WAKE_ASSOC_IOU),
+	/** Recent-window stillness after which a track stops holding its motion
+	*  session open (also the minimum track age). Creates nothing — birth is
+	*  decided by repeated evidence. `SESSION_STILLNESS_WINDOW_MS`. */
+	sessionStillnessWindowMs: number().int().min(5e3).max(12e4).default(SESSION_STILLNESS_WINDOW_MS),
+	/** Observed-time TTL: retire an entry unconfirmed for this long (measured on
+	*  frames-flowing time, not wall-clock). `ENTRY_TTL_MS`. */
+	entryTtlMs: number().int().min(6e4).max(18e5).default(ENTRY_TTL_MS)
+});
+var STATIONARY_DEFAULTS = StationarySettingsSchema.parse({});
+/**
+* Resolve a per-device store blob into typed stationary settings. Unknown/invalid
+* fields fall back to the default for that field (never throws on a bad blob).
+*/
+function resolveStationarySettings(raw) {
+	const pick = (key) => {
+		const parsed = StationarySettingsSchema.shape[key].safeParse(raw[key]);
+		return parsed.success ? parsed.data : STATIONARY_DEFAULTS[key];
+	};
+	return {
+		enabled: pick("enabled"),
+		suppressIou: pick("suppressIou"),
+		wakeAssocIou: pick("wakeAssocIou"),
+		sessionStillnessWindowMs: pick("sessionStillnessWindowMs"),
+		entryTtlMs: pick("entryTtlMs")
+	};
+}
 var TrackingSettingsSchema = object({
 	/**
 	* How much of a detection's box must lie inside a zone (0-1 fraction of the
@@ -71543,56 +72281,6 @@ function resolveTrackingSettings(raw) {
 	};
 }
 //#endregion
-//#region src/pipeline-analytics/stationary-settings.ts
-/**
-* Per-device stationary-object (parked/idle suppression) settings. Cascade: a
-* per-device override on top of the global default, resolved per field (an
-* invalid/missing value falls back to its default — parse never throws).
-* Mirrors `media-settings` / `tracking-settings`.
-*
-* The defaults are the SAME constants the registry uses at runtime
-* (`stationary-types.ts`), imported (not copied) so an unset value and a reset
-* value both resolve to exactly today's behaviour — "reset == unset == today",
-* with no drift. Guarded by a unit test asserting the equality.
-*/
-var StationarySettingsSchema = object({
-	/** Master switch. Off ⇒ this camera gathers no evidence and suppresses
-	*  nothing (every parked object keeps spawning normal tracks). */
-	enabled: boolean().default(true),
-	/** IoU at/above which a detection is the same parked object, unmoved →
-	*  suppress its spawn. `SUPPRESS_IOU`. */
-	suppressIou: number().min(.3).max(.9).default(SUPPRESS_IOU),
-	/** Minimum IoU for a detection to be ASSOCIATED with an entry (confirm or
-	*  wake it) — the overlap gate that stops a different vehicle from waking a
-	*  parked entry (the 617 flood fix). `WAKE_ASSOC_IOU`. */
-	wakeAssocIou: number().min(.02).max(.5).default(WAKE_ASSOC_IOU),
-	/** Recent-window stillness after which a track stops holding its motion
-	*  session open (also the minimum track age). Creates nothing — birth is
-	*  decided by repeated evidence. `SESSION_STILLNESS_WINDOW_MS`. */
-	sessionStillnessWindowMs: number().int().min(5e3).max(12e4).default(SESSION_STILLNESS_WINDOW_MS),
-	/** Observed-time TTL: retire an entry unconfirmed for this long (measured on
-	*  frames-flowing time, not wall-clock). `ENTRY_TTL_MS`. */
-	entryTtlMs: number().int().min(6e4).max(18e5).default(ENTRY_TTL_MS)
-});
-var STATIONARY_DEFAULTS = StationarySettingsSchema.parse({});
-/**
-* Resolve a per-device store blob into typed stationary settings. Unknown/invalid
-* fields fall back to the default for that field (never throws on a bad blob).
-*/
-function resolveStationarySettings(raw) {
-	const pick = (key) => {
-		const parsed = StationarySettingsSchema.shape[key].safeParse(raw[key]);
-		return parsed.success ? parsed.data : STATIONARY_DEFAULTS[key];
-	};
-	return {
-		enabled: pick("enabled"),
-		suppressIou: pick("suppressIou"),
-		wakeAssocIou: pick("wakeAssocIou"),
-		sessionStillnessWindowMs: pick("sessionStillnessWindowMs"),
-		entryTtlMs: pick("entryTtlMs")
-	};
-}
-//#endregion
 //#region src/pipeline-analytics/settings-schema-sections.ts
 /** The detection-knob sections, in their original in-form order. */
 function buildDetectionSettingsSections() {
@@ -72138,10 +72826,45 @@ function buildDetectionSettingsSections() {
 					displayScale: 1e3
 				}
 			]
-		}
+		},
+		buildStillnessScaleSection()
 	];
 }
 /**
+* The per-camera STILLNESS SCALE — one measured number plus its provenance.
+*
+* Its own section rather than a field on `detection-sensitivity` because the
+* two answer different questions: `stationaryThresholdSec` is HOW LONG a
+* settled subject must stay settled, which is an operator preference; this is
+* HOW SLOW counts as settled, which is a fact about the camera and is
+* measured. Mixing them is how a measurement ends up being guessed at.
+*/
+function buildStillnessScaleSection() {
+	return {
+		id: "stillness-scale",
+		title: "Stillness scale (per camera)",
+		description: "How slowly a subject has to move on THIS camera before it counts as settled. A camera looking down a 30 m driveway and one watching a doorway two metres away disagree about this by more than an order of magnitude, so one fleet-wide number cannot be right for both. Leave it at 0 and the camera behaves exactly as it always has (a flat 2 px-per-update bar). Run the `stillness.calibrate` action to measure it from the camera’s own recorded tracks — the run reports what it measured and REFUSES, with a reason, when the evidence is too thin.",
+		columns: 1,
+		fields: [{
+			type: "number",
+			key: "stillnessSpeedFracPerSec",
+			label: "Stillness speed bar",
+			description: "Centroid speed, as a fraction of the subject’s OWN box diagonal, per second, at or below which the subject is not travelling. Subject-relative, so perspective is already divided out; per second, so an irregular on-motion cadence cannot masquerade as speed. 0 = not calibrated (the shipped absolute bar decides, exactly as before). Live reference: 0.0136 on a close, mostly-parked view; 0.3081 on a far view whose subjects only transit.",
+			min: 0,
+			max: 1,
+			step: .001,
+			default: STILLNESS_DEFAULTS.stillnessSpeedFracPerSec
+		}, {
+			type: "text",
+			key: "stillnessCalibrationNote",
+			label: "Last calibration",
+			description: "What the last run measured, from how many samples and tracks, and what it chose — or which named reason it refused for. Display only.",
+			default: STILLNESS_DEFAULTS.stillnessCalibrationNote,
+			readonlyField: true
+		}]
+	};
+}
+/**
 * Re-home the global analytics sections into the per-device `Analytics`
 * top-tab. Every section defaults to the `Analytics` tab (so the
 * device-manager aggregator groups them) AND is marked
@@ -72167,6 +72890,7 @@ function toAnalyticsDeviceSections(sections) {
 *   - `tracking` — the tracker-tuning form incl. the FP knobs (dedup, person↔
 *     animal dedup, class voting, confirm-bypass, per-class min score).
 *   - `stationary-objects` — stationary promotion + occupancy tuning.
+*   - `stillness-scale` — the per-camera measured "how slow is settled" bar.
 * `DeviceDetail` folds `tab: 'detection-pipeline'` top-tab sections into the
 * structural Detection pipeline tab, so re-tagging is all that's needed —
 * there is no admin-ui change and no duplicate render (a section has one tab).
@@ -72175,7 +72899,8 @@ var DETECTION_PIPELINE_SECTION_IDS = new Set([
 	"detection-sensitivity",
 	"confirmation-gate",
 	"tracking",
-	"stationary-objects"
+	"stationary-objects",
+	"stillness-scale"
 ]);
 /**
 * Re-home the detection-knob sections from the `Analytics` top-tab onto the
@@ -75907,9 +76632,23 @@ var customActions = {
 	...locationDiscardActions,
 	...viewerSettingsActions,
 	...photoEnrollActions,
-	...faceRescoreActions
+	...faceRescoreActions,
+	...stillnessCalibrationActions
 };
 /**
+* Width cap on the ONE full frame a debug crop is cut from.
+*
+* A debug crop is a picture for a person, and the plan has already widened the
+* window to a neighbourhood — past this width the extra pixels buy nothing and
+* a 4K native surface would cross the transport for every marked track.
+*/
+var DEBUG_CROP_FETCH_MAX_WIDTH = 1280;
+/** How long a queued debug-crop frame fetch is still worth executing. Past
+*  this the handle's frame has aged out of the runner's retention and the next
+*  decision will ask again with a young one, so the queued entry is dead
+*  weight in a lane real media is waiting in. */
+var DEBUG_CROP_FETCH_STALE_MS = 2e3;
+/**
 * Assist threshold when the caller does not pin one. Packages have their own
 * (0.35, on the zone crop only — `retrain/retrain-assist.ts`); everything else
 * starts here and the operator drops the ones they do not want.
@@ -76734,6 +77473,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	*  the frame path like the stationary one and a cold miss answers the
 	*  measured default. */
 	summarySettingsCache = this.settingsCaches.registerDeviceCache("summary", SETTINGS_CACHE_TTL_MS);
+	/** Per-device STILLNESS SCALE cache — the measured "how slow is settled" bar
+	*  (`stillness-settings.ts`). Read once per FrameProcessor build, so this is
+	*  a cold-path cache; it exists so a calibration applied through
+	*  `stillness.calibrate` reaches the tracker on the next processor rebuild
+	*  rather than on the next addon restart. */
+	stillnessSettingsCache = this.settingsCaches.registerDeviceCache("stillness", SETTINGS_CACHE_TTL_MS);
 	/** Turns stationary appear/depart into package-delivered/picked-up events. */
 	packageDropDetector = null;
 	/**
@@ -76943,7 +77688,51 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	* `docs/decisions/` — the gate is a model input, so this is a deliberate
 	* exception to "model-input crops keep captureCrop".
 	*/
+	/**
+	* The operator-debug crop capture (`pipeline/debug-crop-capture.ts`).
+	*
+	* Null until the transport and the media store exist. Reached from three
+	* decision sites and gated INSIDE the capture on the track's `debug` flag, so
+	* a camera with no marked track pays one map lookup per decision — see the
+	* capture's module doc for why the gate lives there and not at each site.
+	*/
+	captureDebugCropFn = null;
 	captureDisplayCropFn = null;
+	/**
+	* Offer one decision's pixels to the operator-debug crop capture.
+	*
+	* Fire-and-forget and NEVER throws: this is the addon's own bookkeeping, and
+	* a frame path that can be slowed or broken by a diagnostic is worse than no
+	* diagnostic. The gate, the per-track cap and all six refusal reasons live in
+	* the capture (`pipeline/debug-crop-capture.ts`); this is only the seam.
+	*/
+	/**
+	* The CURRENT frame's handle and dims, per camera — the one thing the
+	* salvage-bind observer lacks.
+	*
+	* The tracker knows no `deviceId`, holds no handle and writes no media (that
+	* is the point of `pipeline/tracker/**`), so a growth bind reports its two
+	* boxes and stops. This mirror is what lets the host put those boxes back on
+	* a picture. Written ONLY while some track on this runner is marked
+	* (`residents.anyDebugMarked()`), so an ordinary fleet does not allocate one
+	* object per frame per camera for a diagnostic nobody asked for.
+	*/
+	debugFrameContext = /* @__PURE__ */ new Map();
+	offerDebugCrop(input) {
+		const capture = this.captureDebugCropFn;
+		if (capture === null) return;
+		capture(input).catch((err) => {
+			this.ctx.logger.debug("debug crop offer threw", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					deviceId: input.deviceId,
+					trackId: input.trackId,
+					decision: input.decision,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+		});
+	}
 	captureCrop = null;
 	/** Full NATIVE frame by handle (downscaled worker-side to `maxWidth`), routed
 	*  to the owning runner, PLUS the source `tier`. Captured in the async init
@@ -77308,6 +78097,36 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			isNodeOffline: (nodeId) => this.nodeLiveness.isKnownOffline(nodeId, Date.now())
 		});
 		this.captureCrop = transport.captureCrop;
+		const fetchDebugFullFrame = transport.getNativeFullFrameRgb;
+		this.captureDebugCropFn = createDebugCropCapture({
+			isDebugMarked: (trackId) => this.residents.isDebugMarked(trackId),
+			fetchFrameRgb: async (handle, deviceId, trackId) => {
+				const frame = await this.captureScheduler.request({
+					deviceId,
+					trackId,
+					kind: "other",
+					coalesceKey: captureCoalesceKey(deviceId, "other", trackId),
+					staleAfterMs: DEBUG_CROP_FETCH_STALE_MS,
+					exec: () => fetchDebugFullFrame(handle, DEBUG_CROP_FETCH_MAX_WIDTH)
+				});
+				return frame === null || frame === void 0 ? null : {
+					bytes: frame.data,
+					width: frame.width,
+					height: frame.height
+				};
+			},
+			extractCropRaw: (data, w, h, box) => extractCropRaw(data, w, h, box),
+			drawBoxedFrame: (data, w, h, boxes, options) => drawBoxedFrame(data, w, h, boxes, options ?? {}),
+			putDebugCrop: (put) => stores.mediaStore.put({
+				deviceId: put.deviceId,
+				ownerKind: "track",
+				ownerId: put.trackId,
+				kind: "debugCrop",
+				timestamp: put.timestamp,
+				data: put.data
+			}),
+			logger: logger.child("DebugCrop")
+		});
 		this.eventMediaDispatcher = new EventMediaDispatcher({
 			getRemoteFrame: transport.getRemoteFrame,
 			getNativeCropJpeg: transport.getNativeCropJpeg,
@@ -77364,7 +78183,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					...locationDiscardActions,
 					...viewerSettingsActions,
 					...photoEnrollActions,
-					...faceRescoreActions
+					...faceRescoreActions,
+					...stillnessCalibrationActions
 				},
 				actionHandlers: {
 					...ncHandlers,
@@ -77372,6 +78192,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					...this.buildDebugActionHandlers(),
 					...this.buildPhotoEnrollActionHandlers(),
 					...this.buildFaceRescoreActionHandlers(),
+					...this.buildStillnessCalibrationActionHandlers(),
 					...this.viewerSettingsSnapshots ? makeViewerSettingsActionHandlers(this.viewerSettingsSnapshots) : {}
 				}
 			} : {}
@@ -80308,6 +81129,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			frameHeight: result.frameHeight
 		}, exhaustedIds);
 		const outcome = run.outcome;
+		if (frameHandle !== void 0 && this.residents.anyDebugMarked()) this.debugFrameContext.set(deviceId, {
+			handle: frameHandle,
+			width: result.frameWidth,
+			height: result.frameHeight,
+			timestamp: result.timestamp
+		});
 		const gateNowMs = Date.now();
 		for (const { id, t } of bornCandidates) {
 			if (outcome.undecided.has(id)) {
@@ -80366,6 +81193,32 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 							error: String(err)
 						} });
 					});
+					if (frameHandle !== void 0) {
+						const decision = run.decisions.get(id);
+						this.offerDebugCrop({
+							deviceId,
+							trackId: id,
+							decision: "birth-confirmation",
+							subject: {
+								x: t.bbox.x,
+								y: t.bbox.y,
+								w: t.bbox.w,
+								h: t.bbox.h
+							},
+							frameHandle,
+							frameWidth: result.frameWidth,
+							frameHeight: result.frameHeight,
+							timestamp: gateNowMs,
+							evidence: {
+								className: t.className,
+								source,
+								verdict: "suppression-held",
+								...decision?.cropSource !== void 0 ? { cropSource: decision.cropSource } : {},
+								...decision?.bestScore !== void 0 ? { bestScore: decision.bestScore } : {},
+								judgedCropKept: judged !== void 0
+							}
+						});
+					}
 					log.info("birth suppression held — the gate is not this root detector", {
 						tags: { deviceId },
 						meta: {
@@ -81323,6 +82176,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	async resolveDeviceStationarySettings(deviceId) {
 		return this.stationarySettingsCache.get(deviceId, (id) => this.readDeviceSettings(id, resolveStationarySettings));
 	}
+	/** Per-device stillness scale. An absent/zero bar resolves to `undefined`
+	*  ({@link resolveStillSpeedFracPerSec}) and leaves the state analyzer on
+	*  its original absolute threshold — uncalibrated is exactly today. */
+	async resolveDeviceStillnessSettings(deviceId) {
+		return this.stillnessSettingsCache.get(deviceId, (id) => this.readDeviceSettings(id, resolveStillnessSettings));
+	}
 	/**
 	* Count SHORT + MOTIONLESS track closes per frame cell.
 	*
@@ -82394,6 +83253,32 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					meta: { ...bestShotPromotionMeta(promotionAttempt) }
 				});
 			}
+			if (frameHandle !== void 0) {
+				const heldBbox = this.residents.bestSeenBbox(t.trackId);
+				const rival = heldBbox !== void 0 && heldBbox.frameWidth === frameWidth && heldBbox.frameHeight === frameHeight ? {
+					x: heldBbox.x,
+					y: heldBbox.y,
+					w: heldBbox.w,
+					h: heldBbox.h
+				} : void 0;
+				this.offerDebugCrop({
+					deviceId,
+					trackId: t.trackId,
+					decision: "best-shot",
+					subject: {
+						x: t.bbox.x,
+						y: t.bbox.y,
+						w: t.bbox.w,
+						h: t.bbox.h
+					},
+					...rival !== void 0 ? { rival } : {},
+					frameHandle,
+					frameWidth,
+					frameHeight,
+					timestamp,
+					evidence: { ...bestShotPromotionMeta(promotionAttempt) }
+				});
+			}
 			if (!plan.appendSnapshot && !rollingLastFrame && !bestThumbnail && keyFrame === "skip") continue;
 			targets.push({
 				trackId: t.trackId,
@@ -83693,6 +84578,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		if (!p) {
 			const { minHits, stationaryThresholdSec, minTrackAge, cooldownSec } = await this.resolveDeviceDetectionSensitivitySettings(deviceId);
 			const trk = await this.resolveDeviceTrackingSettings(deviceId);
+			const stillSpeedFracPerSec = resolveStillSpeedFracPerSec(await this.resolveDeviceStillnessSettings(deviceId));
 			p = new FrameProcessor(deviceId, {
 				minHits,
 				iouThreshold: trk.iouThreshold,
@@ -83734,7 +84620,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					vehicle: trk.minSpawnAreaFracVehicle
 				},
 				classGroupAssoc: trk.classGroupAssoc
-			}, { stationaryThresholdSec }, {
+			}, {
+				stationaryThresholdSec,
+				...stillSpeedFracPerSec !== void 0 ? { stillSpeedFracPerSec } : {}
+			}, {
 				minTrackAge,
 				cooldownSec,
 				minTrackAgeMs: trk.minTrackAgeMs
@@ -83747,6 +84636,33 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 						...record
 					}
 				});
+				if (record.gate !== "growth") return;
+				const frame = this.debugFrameContext.get(deviceId);
+				if (frame === void 0 || frame.width !== record.frameWidth) return;
+				this.offerDebugCrop({
+					deviceId,
+					trackId: record.trackId,
+					decision: "growth-rescue",
+					subject: record.trackBbox,
+					rival: record.detBbox,
+					frameHandle: frame.handle,
+					frameWidth: record.frameWidth,
+					frameHeight: record.frameHeight,
+					timestamp: frame.timestamp,
+					evidence: {
+						stage: record.stage,
+						trackClass: record.trackClass,
+						detClass: record.detClass,
+						detScore: record.detScore,
+						iou: record.iou,
+						centroidDistPx: record.centroidDistPx,
+						trackDiagPx: record.trackDiagPx,
+						areaRatio: record.areaRatio,
+						dtMs: record.dtMs,
+						trackAgeMs: record.trackAgeMs,
+						source
+					}
+				});
 			});
 			p.setSpawnRefusalObserver((record) => {
 				this.ctx.logger.info("tracker: detection dropped — nothing downstream received it", {
@@ -85429,6 +86345,109 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	buildFaceRescoreActionHandlers() {
 		return { "face.rescoreTrack": (input) => this.rescoreFaceForTrack(input) };
 	}
+	buildStillnessCalibrationActionHandlers() {
+		return { "stillness.calibrate": (input) => this.calibrateStillnessForDevice(input) };
+	}
+	/**
+	* Measure ONE camera's stillness scale from its own recorded tracks.
+	*
+	* Cost-bounded by construction: one `queryRecent` page of at most
+	* `maxTracks` rows over the requested window, `projection: 'full'` because
+	* the trajectory IS the measurement, and nothing else is read. The arithmetic
+	* is `stillness-scale.ts` and is pure — this method only fetches, reports and
+	* (on `apply`) writes.
+	*
+	* A REFUSAL never writes the bar. It does write the note, because "why is
+	* this camera still on the default" has to be answerable from the form
+	* rather than from a toast nobody kept.
+	*/
+	async calibrateStillnessForDevice(input) {
+		const trackStore = this.trackStore;
+		if (!trackStore) throw new Error("stillness.calibrate: the track store is not ready");
+		const until = Date.now();
+		const since = until - Math.round(input.sinceHours * 36e5);
+		const limits = {
+			...DEFAULT_STILLNESS_CALIBRATION_LIMITS,
+			maxTracks: input.maxTracks
+		};
+		const previous = resolveStillSpeedFracPerSec(await this.resolveDeviceStillnessSettings(input.deviceId));
+		const samples = collectStillnessSamples((await trackStore.queryRecent({
+			deviceIds: [input.deviceId],
+			since,
+			until,
+			limit: limits.maxTracks,
+			projection: "full"
+		})).tracks.map((t) => ({
+			trackId: t.trackId,
+			className: t.className,
+			positions: t.positions.map((pos) => ({
+				x: pos.x,
+				y: pos.y,
+				timestamp: pos.timestamp,
+				bbox: {
+					w: pos.bbox.w,
+					h: pos.bbox.h
+				}
+			}))
+		})), limits);
+		const outcome = calibrateStillnessSpeed(samples, limits);
+		const note = describeStillnessCalibration(outcome);
+		const finite = (v) => Number.isFinite(v) ? v : null;
+		const measurement = {
+			trackCount: outcome.measurement.trackCount,
+			tracksRead: samples.tracksRead,
+			sampleCount: outcome.measurement.sampleCount,
+			p25: finite(outcome.measurement.p25),
+			p50: finite(outcome.measurement.p50),
+			p90: finite(outcome.measurement.p90),
+			medianIntervalSec: finite(outcome.measurement.medianIntervalSec),
+			medianSubjectDiagonalPx: finite(outcome.measurement.medianSubjectDiagonalPx)
+		};
+		let applied = false;
+		if (input.apply) {
+			const patch = {
+				stillnessCalibrationNote: note,
+				stillnessCalibratedAt: until
+			};
+			if (outcome.ok) patch["stillnessSpeedFracPerSec"] = outcome.bar;
+			await this.applyDeviceSettingsPatch({
+				deviceId: input.deviceId,
+				patch
+			});
+			applied = outcome.ok;
+		}
+		this.ctx.logger.info("stillness calibration", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				accepted: outcome.ok,
+				...outcome.ok ? {} : { reason: outcome.reason },
+				...outcome.ok ? {
+					bar: outcome.bar,
+					clampedBy: outcome.clampedBy
+				} : {},
+				previousBar: previous ?? null,
+				applied,
+				windowHours: input.sinceHours,
+				...measurement
+			}
+		});
+		return {
+			deviceId: input.deviceId,
+			since,
+			until,
+			accepted: outcome.ok,
+			...outcome.ok ? {} : { reason: outcome.reason },
+			...outcome.ok ? {
+				bar: outcome.bar,
+				rawBar: outcome.rawBar,
+				clampedBy: outcome.clampedBy
+			} : {},
+			measurement,
+			previousBar: previous ?? null,
+			applied,
+			note
+		};
+	}
 	buildPhotoEnrollActionHandlers() {
 		return {
 			"photo.analyze": async (input) => {
@@ -85893,6 +86912,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			logger: this.ctx.logger,
 			...this.debugNoteArchive !== null ? { noteArchive: this.debugNoteArchive } : {}
 		}, input);
+		this.residents.setDebugMarked(input.deviceId, input.trackId, out.debug);
 		this.ctx.logger.info("track operator flags set", {
 			tags: { deviceId: input.deviceId },
 			meta: {
@@ -86510,6 +87530,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		this.trackingSettingsCache.delete(input.deviceId);
 		this.confirmationGateSettingsCache.delete(input.deviceId);
 		this.mediaSettingsCache.delete(input.deviceId);
+		this.stillnessSettingsCache.delete(input.deviceId);
 		this.forgetDeviceProcessors(input.deviceId);
 		return { success: true };
 	}