@camstack/addon-post-analysis 1.2.662 → 1.2.664

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-C3N1NpST.js");
+const require_clip_model_registry = require("../clip-model-registry-TeNUAAPP.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -59338,56 +59338,143 @@ function sweepOne(deps, deviceId) {
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/package/package-still-capture.ts
-/** A held look frame older than this is not the parcel's picture any more. */
-var PACKAGE_LOOK_FRAME_MAX_AGE_MS = 15e3;
+/**
+* The runner's native lease on a look frame (holdFrames 8) is released about
+* 100 ms after inference, so a handle older than this answers `native-miss` or
+* `preview-only` — promotion runs seconds to minutes after the look (D60).
+*/
+var PACKAGE_NATIVE_HANDLE_MAX_AGE_MS = 1e3;
+/** Total time a promotion may spend landing its still before it ships without (D60). */
+var PACKAGE_STILL_BOUND_MS = 6e3;
+/** One live-source attempt never takes longer than this (a sleeping camera). */
+var PACKAGE_STILL_ATTEMPT_TIMEOUT_MS = 3e3;
+/** Pause between two live attempts. */
+var PACKAGE_STILL_RETRY_PAUSE_MS = 750;
+var PACKAGE_STILL_LIVE_ATTEMPTS = 3;
+var realPause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function jpegOf(reply) {
 	if (reply.tier === "ram-fullframe") return "preview-only";
 	if (reply.jpegBytes !== void 0 && reply.jpegBytes.byteLength > 0) return reply.jpegBytes;
 	if (reply.bytes !== void 0 && reply.bytes.length === reply.width * reply.height * 3) return encodeRgbCropToJpeg(reply.bytes, reply.width, reply.height);
 	return "empty-frame";
 }
+/** One live read, cut off after `limitMs` so a hung camera cannot hold the delivery. */
+async function readLive(source, limitMs) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(null), limitMs);
+	});
+	try {
+		return await Promise.race([source(), timeout]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/** Retry the live source under {@link PACKAGE_STILL_BOUND_MS} until a frame lands (D60). */
+async function liveStill(input, source) {
+	const now = input.now ?? Date.now;
+	const pause = input.pause ?? realPause;
+	const deadline = now() + PACKAGE_STILL_BOUND_MS;
+	let reason = "live-unavailable";
+	let attempts = 0;
+	while (attempts < PACKAGE_STILL_LIVE_ATTEMPTS) {
+		const remaining = deadline - now();
+		if (remaining <= 0) return {
+			jpeg: null,
+			reason: "bound-exhausted",
+			attempts
+		};
+		attempts += 1;
+		try {
+			const jpeg = await readLive(source, Math.min(PACKAGE_STILL_ATTEMPT_TIMEOUT_MS, remaining));
+			if (jpeg !== null && jpeg.byteLength > 0) return {
+				jpeg,
+				reason,
+				attempts
+			};
+			reason = jpeg === null ? "live-unavailable" : "empty-frame";
+		} catch {
+			reason = "live-unavailable";
+		}
+		if (attempts < PACKAGE_STILL_LIVE_ATTEMPTS) await pause(PACKAGE_STILL_RETRY_PAUSE_MS);
+	}
+	return {
+		jpeg: null,
+		reason,
+		attempts
+	};
+}
 /**
 * The entry carrying its still's `keyFrameMediaId`, or the entry unchanged when
 * it already had one or none could be stored (said, with the reason).
+*
+* Ladder: the native handle while its lease can still be alive, then a frame
+* that exists now (retried under a bound). Every landed still is logged next to
+* every miss (D400).
 */
 async function withParcelStill(input) {
 	const { entry, logger } = input;
 	if (entry.keyFrameMediaId !== void 0) return entry;
-	const miss = (reason, detail) => {
+	const tags = { deviceId: entry.deviceId };
+	const miss = (reason, extra = {}) => {
 		logger.warn("package still NOT stored — the delivery ships without a picture of the parcel", {
-			tags: { deviceId: entry.deviceId },
+			tags,
 			meta: {
 				entryId: entry.id,
 				reason,
-				...detail !== void 0 ? { error: detail } : {}
+				...extra
 			}
 		});
 		return entry;
 	};
-	if (input.handle === null) return miss("no-frame-handle");
 	if (input.writer === null) return miss("no-media-store");
+	const now = input.now ?? Date.now;
+	let jpeg = null;
+	let source = "native";
+	let stamp = input.timestamp;
+	let nativeMiss = "no-frame-handle";
+	let liveReason = null;
+	let attempts = 0;
 	try {
-		const reply = await input.query({
-			handle: input.handle,
-			bbox: {
-				x: 0,
-				y: 0,
-				w: entry.frameWidth,
-				h: entry.frameHeight
-			},
-			acceptJpegBytes: true,
-			encodeJpeg: true,
-			pin: require_clip_model_registry.nodePin(input.handle.nodeId)
+		if (input.handle !== null) {
+			const reply = await input.query({
+				handle: input.handle,
+				bbox: {
+					x: 0,
+					y: 0,
+					w: entry.frameWidth,
+					h: entry.frameHeight
+				},
+				acceptJpegBytes: true,
+				encodeJpeg: true,
+				pin: require_clip_model_registry.nodePin(input.handle.nodeId)
+			});
+			if (reply === null) nativeMiss = "native-miss";
+			else {
+				const out = await jpegOf(reply);
+				if (typeof out === "string") nativeMiss = out;
+				else jpeg = out;
+			}
+		}
+		if (jpeg === null && input.live !== null) {
+			const live = await liveStill(input, input.live);
+			attempts = live.attempts;
+			if (live.jpeg !== null) {
+				jpeg = live.jpeg;
+				source = "live";
+				stamp = now();
+			} else liveReason = live.reason;
+		}
+		if (jpeg === null) return miss(liveReason ?? nativeMiss, {
+			...input.handle !== null ? { nativeMiss } : {},
+			...liveReason !== null ? { liveAttempts: attempts } : {}
 		});
-		if (reply === null) return miss("native-miss");
-		const jpeg = await jpegOf(reply);
-		if (typeof jpeg === "string") return miss(jpeg);
 		const keyFrameMediaId = await input.writer.putReplacing({
 			deviceId: entry.deviceId,
 			ownerKind: "track",
 			ownerId: entry.id,
 			kind: "keyFrame",
-			timestamp: input.timestamp,
+			timestamp: stamp,
 			data: Buffer.from(jpeg),
 			subjectBox: {
 				x: entry.bbox.x,
@@ -59398,12 +59485,20 @@ async function withParcelStill(input) {
 				frameHeight: entry.frameHeight
 			}
 		});
+		logger.info("package still stored", {
+			tags,
+			meta: {
+				entryId: entry.id,
+				mediaId: keyFrameMediaId,
+				source
+			}
+		});
 		return {
 			...entry,
 			keyFrameMediaId
 		};
 	} catch (err) {
-		return miss("write-failed", require_clip_model_registry.errMsg(err));
+		return miss("write-failed", { error: require_clip_model_registry.errMsg(err) });
 	}
 }
 /**
@@ -70790,6 +70885,7 @@ Object.freeze({
 		"pageSize": 50
 	} },
 	"device-runs": { "listRuns": { "limit": 50 } },
+	"fan-presets": { "capturePreset": { "steps": [] } },
 	"llm": { "upsertProfile": { "profile": { "__nested__": {
 		"timeoutMs": 6e4,
 		"connectTimeoutMs": 1e4,
@@ -71030,6 +71126,10 @@ Object.freeze({
 			"speed": 2
 		}
 	},
+	"system": { "debugWatch": {
+		"channels": [],
+		"deviceIds": []
+	} },
 	"terminal-session": { "pullOutput": { "waitMs": 0 } },
 	"training": {
 		"planJob": { "selection": { "__nested__": { "workState": "complete" } } },
@@ -71076,6 +71176,7 @@ Object.freeze({
 	],
 	"device-removal-hook": ["listDeviceData"],
 	"failure-contribution": ["list"],
+	"integration-instances": ["listInstances"],
 	"llm": [
 		"getDefaults",
 		"getUsage",
@@ -71117,6 +71218,7 @@ Object.freeze({
 		"listSupportedEntityKinds",
 		"unexposeEntity"
 	],
+	"integration-instances": ["testInstance"],
 	"log-destination": [
 		"cancelRead",
 		"describeRead",
@@ -85215,6 +85317,9 @@ async function renderMosaic(request, logger) {
 * one composition are decisions about the set, and none of them belongs in a
 * shelf that photographs one camera for an absence.
 *
+* A SLEEPING battery camera is woken by one forced capture when the rule leaves
+* it allowed (D998) — bounded, once per gap per camera, never by a poll.
+*
 * Two reads can only ever ADD a camera back, never take one away on their own
 * failure (D49): a wrapper-state read (run in parallel with the capture) that
 * misses or throws keeps the tile, and a freshness read that misses or throws
@@ -85228,6 +85333,15 @@ var NC_LINKED_CAMERA_PREFIX = "nc-linked:";
 function isLinkedStillId(id) {
 	return id.startsWith(NC_LINKED_MOSAIC_PREFIX) || id.startsWith(NC_LINKED_CAMERA_PREFIX);
 }
+/**
+* D998 — the one forced capture that wakes a sleeping battery camera for a
+* sensor notification: the bound it may take, the pause between re-polls of a
+* camera another wake already started, and the gap per camera before it is
+* woken again (a flapping contact must not drain a battery).
+*/
+var NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS = 15e3;
+var NC_LINKED_WAKE_POLL_MS = 1e3;
+var NC_LINKED_WAKE_MIN_GAP_MS = 6e4;
 /** Per camera — the marker's own bound (`SENSOR_MARKER_SNAPSHOT_TIMEOUT_MS`). */
 var SENSOR_LINKED_CAPTURE_TIMEOUT_MS = 2500;
 /** The capture-free wrapper-state read, per camera. It runs IN PARALLEL with
@@ -85260,11 +85374,14 @@ var NcLinkedStillShelf = class {
 	deps;
 	sets = /* @__PURE__ */ new Map();
 	owners = /* @__PURE__ */ new Map();
+	/** setId → when its in-flight wake gives up (the dispatcher waits that long). */
+	pendingWakes = /* @__PURE__ */ new Map();
+	lastWakeAt = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
 	}
 	/** SYNCHRONOUS: the evaluation that follows names these owners. */
-	captureSet(sensorId, cameraIds, atMs) {
+	captureSet(sensorId, cameraIds, atMs, options = { wakeSleeping: false }) {
 		const now = this.deps.now();
 		this.prune(now);
 		const setId = (0, node_crypto.randomUUID)();
@@ -85292,7 +85409,7 @@ var NcLinkedStillShelf = class {
 				camera: cameraId
 			});
 		});
-		this.run(setId, stills, atMs, now).catch((err) => {
+		this.run(setId, stills, atMs, now, options).catch((err) => {
 			this.deps.logger.warn("sensor notification pictures failed — it ships text-only", {
 				tags: { deviceId: sensorId },
 				meta: { error: String(err) }
@@ -85300,6 +85417,15 @@ var NcLinkedStillShelf = class {
 		});
 		return stills;
 	}
+	/**
+	* While a wake of one of this owner's cameras is in flight: the instant it
+	* gives up (its bound plus one poll). `undefined` otherwise — the dispatcher
+	* then keeps its ordinary still-wait.
+	*/
+	pendingUntil(ownerId) {
+		const ref = this.owners.get(ownerId);
+		return ref === void 0 ? void 0 : this.pendingWakes.get(ref.setId);
+	}
 	/** `undefined` = not an owner this shelf minted (or pruned); `[]` = nothing (yet). */
 	get(ownerId) {
 		const ref = this.owners.get(ownerId);
@@ -85321,20 +85447,37 @@ var NcLinkedStillShelf = class {
 	clear() {
 		this.sets.clear();
 		this.owners.clear();
+		this.pendingWakes.clear();
 	}
-	async run(setId, stills, atMs, startedAt) {
-		const results = await Promise.all(stills.cameraIds.map((id) => this.captureOne(id, startedAt)));
+	async run(setId, stills, atMs, startedAt, options) {
+		const ctx = {
+			setId,
+			sensorId: stills.sensorId,
+			startedAt,
+			options
+		};
+		let results;
+		try {
+			results = await Promise.all(stills.cameraIds.map((id) => this.captureOne(id, ctx)));
+		} finally {
+			this.pendingWakes.delete(setId);
+		}
 		const judged = await this.judgeFreshness(stills.sensorId, results, atMs);
 		for (const r of judged) this.logTile(stills.sensorId, r);
 		const landed = judged.filter(isLandedTile);
 		const composed = await this.compose(stills.sensorId, landed, atMs);
 		const undrawable = landed.length - composed.drawn;
+		const woken = judged.filter((r) => r.woken === true).map((r) => r.cameraId);
 		this.deps.logger.info(composed.mosaic.length === 0 ? "sensor notification has no linked picture — it ships text-only" : "sensor notification pictures ready", {
 			tags: { deviceId: stills.sensorId },
 			meta: {
 				cameras: stills.cameraIds.length,
 				landed: composed.drawn,
 				...undrawable > 0 ? { undrawable } : {},
+				...woken.length > 0 ? {
+					woken,
+					waitedMs: this.deps.now() - startedAt
+				} : {},
 				dropped: Object.fromEntries(judged.filter((r) => r.outcome !== "landed").map((r) => [String(r.cameraId), r.outcome])),
 				tookMs: this.deps.now() - startedAt
 			}
@@ -85347,21 +85490,25 @@ var NcLinkedStillShelf = class {
 			mosaic: composed.mosaic
 		});
 	}
-	async captureOne(cameraId, startedAt) {
-		const took = () => this.deps.now() - startedAt;
+	async captureOne(cameraId, ctx) {
+		const took = () => this.deps.now() - ctx.startedAt;
 		if (this.deps.isOnline(cameraId) === false) return {
 			cameraId,
 			outcome: "excluded",
 			reason: "offline",
 			tookMs: took()
 		};
-		const [verdict, capture] = await Promise.all([this.wrapperVerdict(cameraId), this.captureStill(cameraId)]);
-		if (verdict.reason !== null) return {
+		const [verdict, capture] = await Promise.all([this.wrapperVerdict(cameraId), this.captureStill(cameraId, false, SENSOR_LINKED_CAPTURE_TIMEOUT_MS)]);
+		const excluded = (reason) => ({
 			cameraId,
 			outcome: "excluded",
-			reason: verdict.reason,
+			reason,
 			tookMs: took()
-		};
+		});
+		if (verdict.reason === "sleeping") return this.wakeOne(cameraId, ctx);
+		if (verdict.reason === "waking" && ctx.options.wakeSleeping) return this.awaitWaking(cameraId, ctx);
+		if (verdict.reason === "unreachable" && ctx.options.wakeSleeping) return excluded("wake-skipped:unreachable");
+		if (verdict.reason !== null) return excluded(verdict.reason);
 		return {
 			cameraId,
 			...capture,
@@ -85369,9 +85516,84 @@ var NcLinkedStillShelf = class {
 			tookMs: took()
 		};
 	}
-	async captureStill(cameraId) {
+	/** D998: one forced capture, by the rule's leave, at most once per gap per camera. */
+	async wakeOne(cameraId, ctx) {
+		const took = () => this.deps.now() - ctx.startedAt;
+		const skipped = (reason) => ({
+			cameraId,
+			outcome: "excluded",
+			reason,
+			tookMs: took()
+		});
+		if (!ctx.options.wakeSleeping) return skipped("wake-skipped:policy");
+		const last = this.lastWakeAt.get(cameraId);
+		if (last !== void 0 && ctx.startedAt - last < NC_LINKED_WAKE_MIN_GAP_MS) return skipped("wake-skipped:recent-wake");
+		this.lastWakeAt.set(cameraId, ctx.startedAt);
+		this.markPending(ctx);
+		this.deps.logger.info("linked battery camera woken for the sensor notification", {
+			tags: { deviceId: cameraId },
+			meta: {
+				sensorId: ctx.sensorId,
+				ruleIds: ctx.options.ruleIds ?? [],
+				boundMs: NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS
+			}
+		});
+		const capture = await this.captureStill(cameraId, true, NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS);
+		return {
+			cameraId,
+			...this.asWakeResult(capture),
+			woken: true,
+			tookMs: took()
+		};
+	}
+	/** A camera another wake already started: never forced, re-polled within the bound. */
+	async awaitWaking(cameraId, ctx) {
+		const took = () => this.deps.now() - ctx.startedAt;
+		this.markPending(ctx);
+		const polls = Math.floor(NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS / NC_LINKED_WAKE_POLL_MS);
+		for (let i = 0; i < polls; i++) {
+			await new Promise((resolve) => setTimeout(resolve, NC_LINKED_WAKE_POLL_MS));
+			const verdict = await this.wrapperVerdict(cameraId);
+			if (verdict.reason === "waking") continue;
+			if (verdict.reason !== null) return {
+				cameraId,
+				outcome: "excluded",
+				reason: verdict.reason,
+				tookMs: took()
+			};
+			const capture = await this.captureStill(cameraId, false, SENSOR_LINKED_CAPTURE_TIMEOUT_MS);
+			return {
+				cameraId,
+				...this.asWakeResult(capture),
+				woken: true,
+				tookMs: took()
+			};
+		}
+		return {
+			cameraId,
+			outcome: "wake-timeout",
+			woken: true,
+			tookMs: took()
+		};
+	}
+	markPending(ctx) {
+		const until = ctx.startedAt + NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS + NC_LINKED_WAKE_POLL_MS;
+		this.pendingWakes.set(ctx.setId, Math.max(this.pendingWakes.get(ctx.setId) ?? 0, until));
+	}
+	/** A wake that brought nothing back names itself, not the generic `empty`. */
+	asWakeResult(capture) {
+		if (capture.outcome === "timeout") return {
+			...capture,
+			outcome: "wake-timeout"
+		};
+		return capture.outcome === "empty" || capture.outcome === "error" && capture.reason !== "undecodable" ? {
+			...capture,
+			outcome: "wake-refused"
+		} : capture;
+	}
+	async captureStill(cameraId, force, timeoutMs) {
 		try {
-			const shot = await withTimeout$2(this.deps.getSnapshot(cameraId), SENSOR_LINKED_CAPTURE_TIMEOUT_MS, "snapshot cap");
+			const shot = await withTimeout$2(force ? this.deps.getSnapshot(cameraId, { force: true }) : this.deps.getSnapshot(cameraId), timeoutMs, "snapshot cap");
 			if (shot === null || shot.base64.length === 0) return { outcome: "empty" };
 			const jpeg = await this.decodableStill(Buffer.from(shot.base64, "base64"));
 			if (jpeg === null) return {
@@ -86930,6 +87152,13 @@ var NC_RECORDED_FOOTAGE_WAIT_MS = 3e4;
 var NC_STILL_WAIT_MS = 3e3;
 var NC_STILL_WAIT_INTERVAL_MS = 500;
 /**
+* D998 — the longest a sensor notification holds for a linked battery camera
+* that is being woken (`stillDeadline`). A `sent` row is final, so the picture
+* cannot follow the push: it is waited for here, bounded, or never attached.
+* Owners with no wake in flight keep {@link NC_STILL_WAIT_MS}.
+*/
+var NC_LINKED_WAKE_WAIT_MS = 15e3;
+/**
 * How far a still's OWN instant may sit from the trigger and still count as
 * being ABOUT the trigger, for a `delivery: 'immediate'` rule.
 *
@@ -88146,7 +88375,15 @@ var NcDispatcher = class {
 		const firstLook = groupTiles !== null ? null : await this.resolveAttachment(entry, canStillGainMedia(entry) ? "trigger-only" : "any");
 		const footagePending = this.renderFootage(entry);
 		const mosaic = groupView !== void 0 && groupTiles !== null ? await this.groupedMosaic(entry, groupView, groupTiles) : null;
-		const still = mosaic !== null ? mosaic.attachment : firstLook !== null || entry.payload.media === "none" ? firstLook : await this.waitForStill(entry);
+		let waitedMs = 0;
+		let still;
+		if (mosaic !== null) still = mosaic.attachment;
+		else if (firstLook !== null || entry.payload.media === "none") still = firstLook;
+		else {
+			const waited = await this.waitForStill(entry);
+			still = waited.still;
+			waitedMs = waited.waitedMs;
+		}
 		const grouped = groupView !== void 0 && groupMembers !== null ? {
 			windowKey: groupView.key,
 			members: groupView.members.length,
@@ -88171,6 +88408,7 @@ var NcDispatcher = class {
 				recordKind: entry.recordKind,
 				recordId: entry.recordId,
 				policy: entry.payload.media,
+				waitedMs,
 				...entry.payload.mediaImage !== void 0 ? { image: entry.payload.mediaImage } : {},
 				...memberTrackIds.length > 1 ? { memberTrackIds } : {},
 				owners: [...entry.payload.subject.eventId !== void 0 ? [`object:${entry.payload.subject.eventId}`] : [], ...entry.payload.subject.trackId !== void 0 ? [`track:${entry.payload.subject.trackId}`] : []]
@@ -88197,7 +88435,13 @@ var NcDispatcher = class {
 		const subject = entry.payload.subject;
 		const out = [];
 		for (const { ownerId, cameraId } of subject.extraStills ?? []) {
-			const file = await this.linkedStillFile(entry, ownerId, cameraId);
+			let file = await this.linkedStillFile(entry, ownerId, cameraId);
+			for (let polls = 0; file === void 0 && polls < NC_LINKED_WAKE_WAIT_MS / NC_STILL_WAIT_INTERVAL_MS; polls += 1) {
+				const deadline = this.deps.stillDeadline?.(ownerId);
+				if (deadline === void 0 || this.now() >= deadline) break;
+				await this.sleep(NC_STILL_WAIT_INTERVAL_MS);
+				file = await this.linkedStillFile(entry, ownerId, cameraId);
+			}
 			const bytes = file === void 0 ? null : decodeStillBytes(file.base64);
 			if (file === void 0 || bytes === null) {
 				this.deps.logger.info("linked camera picture missing at send — skipped", {
@@ -88684,11 +88928,19 @@ var NcDispatcher = class {
 	*/
 	async waitForStill(entry) {
 		const subject = entry.payload.subject;
-		if (this.now() - subject.timestamp > NC_STILL_WAIT_MAX_AGE_MS) return this.resolveAttachment(entry, "any");
-		if (subject.eventId === void 0 && subject.trackId === void 0) return null;
-		const attempts = Math.floor(NC_STILL_WAIT_MS / NC_STILL_WAIT_INTERVAL_MS);
-		for (let i = 0; i < attempts; i += 1) {
+		if (this.now() - subject.timestamp > NC_STILL_WAIT_MAX_AGE_MS) return {
+			still: await this.resolveAttachment(entry, "any"),
+			waitedMs: 0
+		};
+		if (subject.eventId === void 0 && subject.trackId === void 0) return {
+			still: null,
+			waitedMs: 0
+		};
+		const startedAt = this.now();
+		let waitedMs = 0;
+		for (let i = 0; waitedMs < this.stillWaitBoundMs(entry, startedAt); i += 1) {
 			await this.sleep(NC_STILL_WAIT_INTERVAL_MS);
+			waitedMs += NC_STILL_WAIT_INTERVAL_MS;
 			const still = await this.resolveAttachment(entry, "trigger-only");
 			if (still !== null) {
 				this.deps.logger.info("the still landed during the bounded wait", {
@@ -88700,10 +88952,32 @@ var NcDispatcher = class {
 						kind: still.name
 					}
 				});
-				return still;
+				return {
+					still,
+					waitedMs
+				};
 			}
 		}
-		return this.resolveAttachment(entry, "any");
+		return {
+			still: await this.resolveAttachment(entry, "any"),
+			waitedMs
+		};
+	}
+	/**
+	* How long this row's still poll may run: {@link NC_STILL_WAIT_MS}, or — while
+	* the shelf says a linked camera of this row is being woken — until that
+	* wake gives up, at most {@link NC_LINKED_WAKE_WAIT_MS} (D998).
+	*/
+	stillWaitBoundMs(entry, startedAt) {
+		const subject = entry.payload.subject;
+		const owners = [...subject.trackId !== void 0 ? [subject.trackId] : [], ...(subject.extraStills ?? []).map((extra) => extra.ownerId)];
+		let deadline;
+		for (const ownerId of owners) {
+			const until = this.deps.stillDeadline?.(ownerId);
+			if (until !== void 0 && (deadline === void 0 || until > deadline)) deadline = until;
+		}
+		if (deadline === void 0) return NC_STILL_WAIT_MS;
+		return Math.max(NC_STILL_WAIT_MS, Math.min(NC_LINKED_WAKE_WAIT_MS, deadline - startedAt));
 	}
 	/**
 	* The grouped MOSAIC (D692 §6.2): one tile per member, at most
@@ -88851,8 +89125,8 @@ var NcDispatcher = class {
 			return ts !== void 0 && this.now() - ts <= NC_STILL_WAIT_MAX_AGE_MS;
 		});
 		await look("trigger-only", pollable());
-		const attempts = Math.floor(NC_STILL_WAIT_MS / NC_STILL_WAIT_INTERVAL_MS);
-		for (let i = 0; i < attempts && pollable().length > 0; i += 1) {
+		const startedAt = this.now();
+		for (let waited = 0; waited < this.stillWaitBoundMs(entry, startedAt) && pollable().length > 0; waited += NC_STILL_WAIT_INTERVAL_MS) {
 			await this.sleep(NC_STILL_WAIT_INTERVAL_MS);
 			await look("trigger-only", pollable());
 		}
@@ -104372,7 +104646,7 @@ function beginLinkedStills(host, request) {
 	if (rowCameraIds.length > 0 && rowShown.length === 0) return void 0;
 	const shown = host.unmutedCameras(cameraIds);
 	const involved = [sensorId, ...rowShown];
-	if (!host.rules.listEnabled("device-event").some((rule) => {
+	const wanting = host.rules.listEnabled("device-event").filter((rule) => {
 		if (ruleShipsNoStill(rule)) return false;
 		if (!deviceEventRuleMayFireOnKind(rule, sensorKind, sensorRaised)) return false;
 		const excluded = rule.conditions.devicesExclude;
@@ -104383,9 +104657,14 @@ function beginLinkedStills(host, request) {
 		})) return false;
 		const devices = rule.conditions.devices;
 		return devices === void 0 || devices.length === 0 || devices.some((id) => involved.includes(id));
-	})) return void 0;
+	});
+	if (wanting.length === 0) return void 0;
+	const wakeSleeping = wanting.some((rule) => rule.media?.wakeSleepingCamera !== false);
 	for (const cameraId of cameraIds) if (!shown.includes(cameraId)) host.reportLinkedCameraMuted(cameraId, sensorId);
-	return shown.length > 0 ? shelf.captureSet(sensorId, shown, atMs) : void 0;
+	return shown.length > 0 ? shelf.captureSet(sensorId, shown, atMs, {
+		wakeSleeping,
+		ruleIds: wanting.map((rule) => rule.id)
+	}) : void 0;
 }
 /**
 * A muted camera left out of a linked set — one INFO line per camera per
@@ -107108,6 +107387,7 @@ var NotificationCenter = class {
 			...deps.dispatcher,
 			logger: this.logger.child("dispatch"),
 			texts: this.texts,
+			stillDeadline: (ownerId) => isLinkedStillId(ownerId) ? this.linkedStills?.pendingUntil(ownerId) : void 0,
 			getMediaForOwner: async (ownerKind, ownerId, eventScope) => {
 				const held = isSyntheticId(ownerId) ? this.syntheticMedia.get(ownerId) : void 0;
 				if (held !== void 0) return held.files;
@@ -109691,7 +109971,10 @@ var BuildNotificationCenter = class extends BuildNotificationCenterBase {
 			},
 			readAlerts: () => api.alerts.list.query({ limit: 5e3 }),
 			emitBusEvent: (event) => this.ctx.eventBus.emit(event),
-			getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }),
+			getSnapshot: (deviceId, opts) => api.snapshot.getSnapshot.query(opts?.force === true ? {
+				deviceId,
+				force: true
+			} : { deviceId }),
 			recognitionOutlook: ({ deviceId, trackId, className, labelKind, now }) => recognitionOutlook({
 				className,
 				...labelKind !== void 0 ? { labelKind } : {},
@@ -128056,11 +128339,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			const lookFrame = this.frameState.packageLookFrames.get(input.deviceId);
 			promoteWithStill({
 				entry,
-				handle: lookFrame !== void 0 && input.timestamp - lookFrame.at <= PACKAGE_LOOK_FRAME_MAX_AGE_MS ? lookFrame.handle : null,
+				handle: lookFrame !== void 0 && input.timestamp - lookFrame.at <= PACKAGE_NATIVE_HANDLE_MAX_AGE_MS ? lookFrame.handle : null,
 				timestamp: lookFrame?.at ?? input.timestamp,
 				query: (request) => this.queryPackageSceneCrop(request),
 				writer: this.mediaStore,
 				logger: this.ctx.logger,
+				live: async () => {
+					const snap = await this.ctx.api.snapshot.getSnapshot.query({ deviceId: input.deviceId });
+					return snap === null ? null : Uint8Array.from(Buffer.from(snap.base64, "base64"));
+				},
 				detector: this.packageDropDetector
 			}).catch((err) => {
 				this.ctx.logger.warn("package promotion failed", {