@camstack/addon-provider-hikvision 1.2.46 → 1.2.49

package/dist/addon.mjs

@@ -8502,6 +8502,112 @@ var TIMEZONES = [
 function findTimezone(id) {
 	return TIMEZONES.find((tz) => tz.id === id);
 }
+/**
+* Distinct (device, family, variant) counters one instance will hold.
+*
+* A large fleet x the handful of families any single addon reports, with
+* slack. At ~200 B per counter this is a ~100 KB ceiling on a process that
+* already declares an RSS budget in the gigabytes.
+*/
+var MAX_KEYS = 1024;
+/**
+* Where reasons past {@link MAX_REASONS_PER_KEY} go.
+*
+* They are FOLDED, never dropped: `attempts - succeeded` must always equal the
+* sum of the reason counts, or the ratio stops adding up.
+*/
+var OVERFLOW_REASON = "other";
+/** `deviceId` + `family` + optional `variant`, flattened into the map key. */
+function counterKey(deviceId, family, variant) {
+	return variant === void 0 ? `${deviceId}${family}` : `${deviceId}${family}${variant}`;
+}
+/**
+* A bounded set of per-camera, cumulative failure counters.
+*
+* One instance per contributing subsystem. `note` is O(1) and allocation-free
+* on the steady path; `snapshot` reads without mutating anything.
+*/
+var FailureCounters = class {
+	maxKeys;
+	maxReasons;
+	counters = /* @__PURE__ */ new Map();
+	refused = 0;
+	constructor(maxKeys = MAX_KEYS, maxReasons = 16) {
+		this.maxKeys = maxKeys;
+		this.maxReasons = maxReasons;
+	}
+	/**
+	* Counters refused because {@link MAX_KEYS} was already held.
+	*
+	* Cumulative for the life of the instance: a bound that bit is a fact about
+	* the deployment, and a surface that hid it would under-report a fleet
+	* precisely when the fleet got large enough to matter.
+	*/
+	get keysRefused() {
+		return this.refused;
+	}
+	/** Counters currently held. */
+	get size() {
+		return this.counters.size;
+	}
+	/**
+	* Fold one observation in.
+	*
+	* A non-positive or non-integer `deviceId` is REFUSED rather than bucketed:
+	* see the module docblock — an entry that cannot name its camera is worse
+	* than no entry.
+	*/
+	note(observation, nowMs) {
+		if (!Number.isInteger(observation.deviceId) || observation.deviceId <= 0) return;
+		const key = counterKey(observation.deviceId, observation.family, observation.variant);
+		let counter = this.counters.get(key);
+		if (counter === void 0) {
+			if (this.counters.size >= this.maxKeys) {
+				this.refused += 1;
+				return;
+			}
+			counter = {
+				deviceId: observation.deviceId,
+				family: observation.family,
+				variant: observation.variant,
+				sinceMs: nowMs,
+				attempts: 0,
+				succeeded: 0,
+				reasons: /* @__PURE__ */ new Map()
+			};
+			this.counters.set(key, counter);
+		}
+		counter.attempts += 1;
+		if (observation.reason === void 0) {
+			counter.succeeded += 1;
+			return;
+		}
+		const reason = counter.reasons.has(observation.reason) || counter.reasons.size < this.maxReasons ? observation.reason : OVERFLOW_REASON;
+		counter.reasons.set(reason, (counter.reasons.get(reason) ?? 0) + 1);
+	}
+	/** Read every counter. Never mutates — see the module docblock. */
+	snapshot(nowMs) {
+		const out = [];
+		for (const counter of this.counters.values()) out.push({
+			deviceId: counter.deviceId,
+			family: counter.family,
+			...counter.variant !== void 0 ? { variant: counter.variant } : {},
+			sinceMs: counter.sinceMs,
+			atMs: nowMs,
+			attempts: counter.attempts,
+			succeeded: counter.succeeded,
+			reasons: [...counter.reasons.entries()].map(([reason, count]) => ({
+				reason,
+				count
+			})).toSorted((a, b) => b.count - a.count)
+		});
+		return out;
+	}
+	/** Drop everything (host disposal). */
+	clear() {
+		this.counters.clear();
+	}
+};
 var MODEL_FORMATS = [
 	"onnx",
 	"coreml",
@@ -13757,7 +13863,26 @@ var FailureContributionSchema = object({
 	/** The loss, partitioned. Sums to `attempts - succeeded`. */
 	reasons: array(FailureReasonCountSchema).readonly()
 });
-method(_void(), array(FailureContributionSchema).readonly());
+var failureContributionCapability = {
+	name: "failure-contribution",
+	scope: "system",
+	mode: "collection",
+	internal: true,
+	methods: { 
+	/**
+	* This addon's per-camera failure counters, read live from bounded in-RAM
+	* state it already keeps. Inert: no persistence, no sampling, no timer.
+	*
+	* READING NEVER RESETS. The counters are CUMULATIVE since `sinceMs`, and a
+	* consumer that wants a rate differences two reads. A draining read would
+	* make two operators with the page open each destroy half of the other's
+	* numbers, and `load-contribution` already settled the same question the
+	* same way for `cpuSeconds`.
+	*/
+list: method(_void(), array(FailureContributionSchema).readonly()) },
+	/** In-process only — enumerated through `addons.listCapabilityProviders`. */
+	mount: { kind: "skip" }
+};
 var LoadContributionSchema = object({
 	role: _enum([
 		"decode",
@@ -14065,6 +14190,50 @@ var NodeProcessSchema = object({
 	/** Wall-clock uptime (seconds). Parsed from `ps etime`. */
 	uptimeSec: number()
 });
+/**
+* One retained container-memory reading.
+*
+* `atMs` is the timestamp of the PROCESS snapshot taken in the same tick, not
+* a second clock: that is what makes "processes sum to X, container says Y"
+* subtractable per point rather than an eyeballed comparison of two series
+* sampled at different instants.
+*
+* A reduced window keeps the sample with the LARGEST `currentBytes` in each
+* bucket, WHOLE. Taking a per-field maximum would synthesise a row whose parts
+* never coexisted, and a mean would smear away the peak this exists to find.
+*/
+var ContainerMemoryPointSchema = object({
+	/** Which hierarchy answered, so a reading is never ambiguous. */
+	source: _enum(["cgroup-v2", "cgroup-v1"]),
+	/** `memory.current` (v2) / `memory.usage_in_bytes` (v1). Always known. */
+	currentBytes: number(),
+	/** The cgroup's ceiling. `null` = NO LIMIT — never a sentinel, never zero. */
+	limitBytes: number().nullable(),
+	/** Anonymous pages: the closest thing to "what the processes allocated". */
+	anonBytes: number().nullable(),
+	/** Page cache. Charged to the cgroup, owned by no process. */
+	fileBytes: number().nullable(),
+	/**
+	* Shared memory — and the field that explained the largest single surprise.
+	* The i915 driver backs GPU buffers with shmem, so an inference pool or a
+	* hardware-decode session holding DRM objects is charged HERE and appears
+	* nowhere in a `ps` scan.
+	*/
+	shmemBytes: number().nullable(),
+	/** Kernel slab charged to this cgroup. `null` on v1, which never publishes it. */
+	slabBytes: number().nullable(),
+	/**
+	* Shrinkable i915 GEM object bytes, from debugfs.
+	*
+	* **Host-wide across every DRM client, NOT cgroup-scoped.** It is not a
+	* component of `currentBytes` and must not be subtracted from it; it says
+	* what put the shmem there, where `shmemBytes` only says how much.
+	*
+	* `null` wherever debugfs is not mounted — which is inside every camstack
+	* container today — and on any node with no Intel GPU.
+	*/
+	gpuShmemBytes: number().nullable()
+}).extend({ atMs: number() });
 var DumpHeapSnapshotInputSchema = object({ 
 /** The addon whose runner should dump a heap snapshot. */
 addonId: string() });
@@ -14128,6 +14297,21 @@ var NodeLoadSeriesSchema = object({
 	/** One entry per function seen in the window, heaviest-first. */
 	series: array(LoadFunctionSeriesSchema).readonly(),
 	/**
+	* The CONTAINER's memory over the same window, oldest-first.
+	*
+	* Sits next to `series` rather than in a method of its own because the whole
+	* question is a subtraction: the per-process rows in `series` sum to one
+	* number and this one is another, and an operator who has to issue two calls
+	* to compare them will compare two different instants. Same reader, same
+	* `sinceMs`, same `bucketMs`, same timestamps.
+	*
+	* **EMPTY means ABSENT, never zero.** A node with no cgroup — a developer
+	* Mac, a bare-metal host, a container with the hierarchy hidden — reports no
+	* points at all. A zero here would be indistinguishable from a healthy
+	* container and is precisely the lie this field exists to avoid.
+	*/
+	containerMemory: array(ContainerMemoryPointSchema).readonly(),
+	/**
 	* Width of one returned bucket, in ms. Equals the sampling cadence when no
 	* reduction was needed — so a caller can always say what one point covers
 	* without having to know whether it was reduced.
@@ -28060,10 +28244,10 @@ var rebootCapability = {
 * recording config. NOTE on events (source of truth, R5/C3): this cap carries
 * NO event surface — `getPlaybackManifest` returns playlist URLs only. Timeline
 * events (motion/object/audio) come from `pipelineAnalytics` (durable SQLite
-* rows); the recorder's internal EventMap markers are ephemeral in-RAM
-* annotations that are not exposed here and must not be treated as an event
-* feed. Event<->footage joins are by time, padded with the shared `EVENT_PAD_MS`
-* (`interfaces/recording-config.ts`).
+* rows) and are the ONLY event surface — the recorder has none. The in-RAM
+* playback markers it used to build were deleted on 2026-08-29 because nothing
+* ever read them. Event<->footage joins are by time, padded with the shared
+* `EVENT_PAD_MS` (`interfaces/recording-config.ts`).
 */
 var RecordingStatusSchema = object({
 	deviceId: number(),
@@ -43590,6 +43774,15 @@ var DEFAULT_BACKLOG_MS = 200;
 var MAX_BACKLOG_MS = 5e3;
 var MIN_BACKLOG_MS = 20;
 /**
+* The ONE place the operator's backlog request becomes the enforced bound.
+* `start()` sizes the byte window from it and `ability.maxBacklogMs` reports
+* it — a second clamp would let the number a caller reads drift from the
+* number the buffer honours.
+*/
+function clampBacklogMs(requested) {
+	return Math.max(MIN_BACKLOG_MS, Math.min(MAX_BACKLOG_MS, requested ?? DEFAULT_BACKLOG_MS));
+}
+/**
 * Fixed audioData PUT-body chunk size, in bytes. Encoded µ-law bytes are
 * accumulated and flushed to the sticky PUT in FIXED chunks of this size
 * (the sub-chunk remainder is held until the next flush, and the trailing
@@ -43658,6 +43851,36 @@ var HikvisionIntercomSession = class {
 	get audioCodec() {
 		return this.codec;
 	}
+	/**
+	* Effective PCM backlog bound, in ms — the operator's value clamped to
+	* [{@link MIN_BACKLOG_MS}, {@link MAX_BACKLOG_MS}], i.e. what the session is
+	* actually enforcing rather than what it was asked for. Readable before
+	* `start()` because the clamp is pure.
+	*/
+	get backlogMs() {
+		return clampBacklogMs(this.opts.maxBacklogMs);
+	}
+	/**
+	* The firmware's talk-back format — `IntercomStatus.ability`.
+	*
+	* Every field is a value this session already resolved against the camera;
+	* nothing here is a default standing in for a probe. It was declared,
+	* mirrored into runtime state and written by NOBODY while these exact
+	* values were in hand and only reaching a log line (D281).
+	*
+	* `duplex` is the one judgement call: ISAPI two-way audio is a single
+	* `audioData` channel and the provider enforces one active session per
+	* camera, so `half` is reported. `full` would be the dangerous direction —
+	* a consumer that believes it may listen while speaking takes no lock.
+	*/
+	get ability() {
+		return {
+			codecs: [this.codec],
+			sampleRate: HIKVISION_INTERCOM_SAMPLE_RATE,
+			duplex: "half",
+			maxBacklogMs: this.backlogMs
+		};
+	}
 	async start() {
 		if (this.stream) return;
 		const desiredChannel = this.opts.channelId ?? "1";
@@ -43716,7 +43939,7 @@ var HikvisionIntercomSession = class {
 			});
 			this.stop(reason).catch(() => {});
 		});
-		const wantedBacklogMs = Math.max(MIN_BACKLOG_MS, Math.min(MAX_BACKLOG_MS, this.opts.maxBacklogMs ?? DEFAULT_BACKLOG_MS));
+		const wantedBacklogMs = this.backlogMs;
 		this.bytesPerSecond = HIKVISION_INTERCOM_SAMPLE_RATE * 2;
 		this.maxBacklogBytes = Math.max(160, Math.floor(wantedBacklogMs / 1e3 * this.bytesPerSecond));
 		this.stream = stream;
@@ -43898,6 +44121,90 @@ var HikvisionIntercomSession = class {
 	}
 };
 //#endregion
+//#region src/intercom/intercom-failure-report.ts
+/**
+* Per-camera talk-back counters, published through `failure-contribution`.
+*
+* ## The number that was never divided
+*
+* The rate-mismatch drop had ONE warn line and no counter, so "how much
+* talk-back is this camera losing" was answerable only by grepping Loki and
+* hand-correlating timestamps — the exact cost `failure-contribution` exists to
+* remove. And a bare drop count could not have answered it either: 40 drops out
+* of 40 pushes and 40 out of 40 000 are opposite findings that produce
+* identical log volume.
+*
+* So EVERY `pushTalkAudio` outcome on a live talk session is noted from the one
+* place that decides it — the accepted ones too. {@link FailureCounters}
+* carries `attempts` as the denominator and `succeeded` as the numerator, and
+* the reasons partition the rest. A success counted somewhere else would drift
+* from the failures and turn the ratio into fiction.
+*
+* ## `variant` is the wire codec, and it is honest
+*
+* `failure-contribution` keeps `variant` for a second dimension WITHIN a
+* family, and here the useful one is the format the caller pushed: an operator
+* asking "why is 617 silent" needs to know whether HomeKit's Opus or Alexa's
+* raw PCM is the half that is failing. The provider is handed that value on
+* every call, so it is reported rather than guessed — absent, never invented.
+*
+* ## Process-wide, because a counter is
+*
+* One addon is one process (D2) and every camera this addon owns lives in it,
+* so the instance is module-scoped: the cameras note into it and the addon
+* registers ONE `failure-contribution` provider that reads it. `sinceMs` is the
+* incarnation marker — a respawned runner restarts from zero and says so.
+* Reading NEVER drains.
+*/
+/** One `pushTalkAudio` call against an open talk session. */
+var FAMILY_INTERCOM_TALK = "intercom-talk";
+/** The push arrived with a sequence number at or below the last accepted one. */
+var REASON_TALK_OUT_OF_ORDER = "out-of-order";
+/** The payload decoded to zero bytes. */
+var REASON_TALK_EMPTY = "empty-frame";
+/** More than one channel — every camera here is mono-only. */
+var REASON_TALK_NOT_MONO = "not-mono";
+/** `s16le` push with no `sampleRate`; the rate is ambiguous, not assumed. */
+var REASON_TALK_NO_SAMPLE_RATE = "missing-sample-rate";
+/** The wire codec has no path onto this camera's talk channel. */
+var REASON_TALK_CODEC_UNSUPPORTED = "codec-unsupported";
+/** The Opus decode path threw or could not open its session. */
+var REASON_TALK_OPUS_FAILED = "opus-decode-failed";
+/**
+* The addon's talk-back counters. One instance per process; the export at the
+* bottom of this file IS that instance.
+*/
+var IntercomFailureReport = class {
+	now;
+	counters;
+	constructor(now = Date.now, counters = new FailureCounters()) {
+		this.now = now;
+		this.counters = counters;
+	}
+	/**
+	* Note one `pushTalkAudio` outcome. `reason` absent = the frame reached the
+	* camera's talk channel.
+	*/
+	noteTalkFrame(deviceId, wireCodec, reason) {
+		this.counters.note({
+			deviceId,
+			family: FAMILY_INTERCOM_TALK,
+			variant: wireCodec,
+			...reason !== void 0 ? { reason } : {}
+		}, this.now());
+	}
+	/** The `failure-contribution` provider's payload. Reads, never resets. */
+	list() {
+		return this.counters.snapshot(this.now());
+	}
+	/** Addon disposal. */
+	clear() {
+		this.counters.clear();
+	}
+};
+/** The process-wide instance every camera in this addon notes into. */
+var intercomFailureReport = new IntercomFailureReport();
+//#endregion
 //#region src/intercom/intercom-orchestrator.ts
 var DEFAULT_OPUS_SAMPLE_RATE = 48e3;
 var DEFAULT_OPUS_CHANNELS = 1;
@@ -43915,6 +44222,14 @@ var IntercomOrchestrator = class {
 		return this.session !== null && !this.session.closed;
 	}
 	/**
+	* The live talk session's firmware ability, or `null` when no session is
+	* open. Read by the camera at `startSession` so the WebRTC path writes
+	* `IntercomStatus.ability` from the same source the raw-PCM path does.
+	*/
+	get ability() {
+		return this.session === null || this.session.closed ? null : this.session.talkSession.ability;
+	}
+	/**
 	* Subscribe to session-close notifications. The listener fires exactly
 	* once per session with the resolved `IntercomCloseReason` + stats, so
 	* the camera layer can surface WHY a talk session ended (the prime
@@ -44176,6 +44491,193 @@ function errMsg$1(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
+//#region src/intercom/talk-pcm-transcoder.ts
+/** libav codec name of a linear little-endian 16-bit PCM decode session. */
+var TALK_PCM_CODEC = "pcm_s16le";
+/** The transcoder was already closed — the talk session ended under the push. */
+var REASON_PCM_CLOSED = "pcm-transcoder-closed";
+/** The caller's declared source rate is not a usable positive integer. */
+var REASON_PCM_BAD_RATE = "pcm-bad-source-rate";
+/** The frame is empty or holds half a sample — malformed, not convertible. */
+var REASON_PCM_ODD_BYTES = "pcm-odd-bytes";
+/** No `audio-codec` provider is mounted on this cluster. */
+var REASON_PCM_NO_CODEC_CAP = "pcm-audio-codec-unavailable";
+/** The codec cap refused to open a linear-PCM decode session. */
+var REASON_PCM_SESSION_OPEN_FAILED = "pcm-resample-session-failed";
+/** The push/pull round-trip through the codec cap threw. */
+var REASON_PCM_CONVERT_FAILED = "pcm-resample-failed";
+function errMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+var TalkPcmTranscoder = class {
+	opts;
+	active = null;
+	closed = false;
+	constructor(opts) {
+		this.opts = opts;
+	}
+	/** The open codec session, or `null` before the first converted frame. */
+	get sessionId() {
+		return this.active?.sessionId ?? null;
+	}
+	/**
+	* Convert one frame to the camera's rate and hand every produced chunk to
+	* `feed`.
+	*
+	* Returns `null` when the frame was converted and fed, or the REASON string
+	* it was refused for — already logged, with nothing fed.
+	*/
+	async feedResampled(frame) {
+		if (this.closed) {
+			this.refuse(REASON_PCM_CLOSED, {});
+			return REASON_PCM_CLOSED;
+		}
+		const sourceSampleRate = frame.sourceSampleRate;
+		if (!Number.isInteger(sourceSampleRate) || sourceSampleRate <= 0) {
+			this.refuse(REASON_PCM_BAD_RATE, { sourceSampleRate });
+			return REASON_PCM_BAD_RATE;
+		}
+		if (frame.pcm.length === 0 || (frame.pcm.length & 1) !== 0) {
+			this.refuse(REASON_PCM_ODD_BYTES, { bytes: frame.pcm.length });
+			return REASON_PCM_ODD_BYTES;
+		}
+		let api;
+		try {
+			api = this.opts.resolveAudioCodec();
+		} catch (err) {
+			this.refuse(REASON_PCM_NO_CODEC_CAP, { error: errMessage(err) });
+			return REASON_PCM_NO_CODEC_CAP;
+		}
+		if (this.active !== null && this.active.sourceSampleRate !== sourceSampleRate) {
+			const previous = this.active.sourceSampleRate;
+			await this.disposeSession(api, "source-rate-changed");
+			this.opts.logger.info("intercom: pcm resample source rate changed — session recreated", {
+				tags: { deviceId: this.opts.deviceId },
+				meta: {
+					previousSourceSampleRate: previous,
+					sourceSampleRate
+				}
+			});
+		}
+		if (this.active === null) try {
+			const created = await api.createDecodeSession({
+				codec: TALK_PCM_CODEC,
+				sourceSampleRate,
+				sourceChannels: 1,
+				targetSampleRate: this.opts.targetSampleRate,
+				targetChannels: 1,
+				targetFormat: "s16le",
+				tag: this.opts.tag
+			});
+			this.active = {
+				sessionId: created.sessionId,
+				nodeId: created.nodeId,
+				sourceSampleRate
+			};
+			this.opts.logger.info("intercom: pcm resample session opened", {
+				tags: { deviceId: this.opts.deviceId },
+				meta: {
+					codec: TALK_PCM_CODEC,
+					codecSessionId: created.sessionId,
+					codecNodeId: created.nodeId,
+					sourceSampleRate,
+					targetSampleRate: this.opts.targetSampleRate,
+					tag: this.opts.tag
+				}
+			});
+		} catch (err) {
+			this.refuse(REASON_PCM_SESSION_OPEN_FAILED, {
+				sourceSampleRate,
+				targetSampleRate: this.opts.targetSampleRate,
+				error: errMessage(err)
+			});
+			return REASON_PCM_SESSION_OPEN_FAILED;
+		}
+		const session = this.active;
+		try {
+			await api.pushEncodedFrame({
+				sessionId: session.sessionId,
+				nodeId: session.nodeId,
+				data: new Uint8Array(frame.pcm.buffer, frame.pcm.byteOffset, frame.pcm.byteLength)
+			});
+			const chunks = await api.pullPcm({
+				sessionId: session.sessionId,
+				nodeId: session.nodeId,
+				maxCount: 8
+			});
+			for (const chunk of chunks) {
+				const out = Buffer.from(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength);
+				if (out.length > 0) this.opts.feed(out);
+			}
+			return null;
+		} catch (err) {
+			this.refuse(REASON_PCM_CONVERT_FAILED, {
+				codecSessionId: session.sessionId,
+				sourceSampleRate,
+				targetSampleRate: this.opts.targetSampleRate,
+				error: errMessage(err)
+			});
+			await this.disposeSession(api, "convert-failed");
+			return REASON_PCM_CONVERT_FAILED;
+		}
+	}
+	/**
+	* Close the codec session. Idempotent, and called from the provider's
+	* `endTalkSession` so the session dies with the talk session it served.
+	*/
+	async close() {
+		this.closed = true;
+		if (this.active === null) return;
+		let api;
+		try {
+			api = this.opts.resolveAudioCodec();
+		} catch (err) {
+			this.opts.logger.debug("intercom: pcm resample close skipped — audio-codec gone", {
+				tags: { deviceId: this.opts.deviceId },
+				meta: {
+					codecSessionId: this.active.sessionId,
+					error: errMessage(err)
+				}
+			});
+			this.active = null;
+			return;
+		}
+		await this.disposeSession(api, "talk-session-ended");
+	}
+	/** Close + forget the current session. Never throws. */
+	async disposeSession(api, why) {
+		const session = this.active;
+		this.active = null;
+		if (session === null) return;
+		try {
+			await api.closeSession({
+				sessionId: session.sessionId,
+				nodeId: session.nodeId
+			});
+		} catch (err) {
+			this.opts.logger.debug("intercom: pcm resample closeSession error (continuing)", {
+				tags: { deviceId: this.opts.deviceId },
+				meta: {
+					codecSessionId: session.sessionId,
+					why,
+					error: errMessage(err)
+				}
+			});
+		}
+	}
+	/** One warn per refused frame. A branch that drops work says so. */
+	refuse(reason, meta) {
+		this.opts.logger.warn("intercom: pcm talk frame refused — not converted, nothing fed", {
+			tags: { deviceId: this.opts.deviceId },
+			meta: {
+				reason,
+				targetSampleRate: this.opts.targetSampleRate,
+				...meta
+			}
+		});
+	}
+};
+//#endregion
 //#region src/intercom/werift-intercom-peer.ts
 var _werift;
 async function loadWerift() {
@@ -45223,13 +45725,20 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 	* Called at the four points that open or close a session — and seeded at
 	* registration, so the slice says `talking: false` from boot rather than
 	* only after the first session.
+	*
+	* `ability` is STICKY: it is the firmware's negotiated format, learned when a
+	* session opens and still true after it closes, so a caller reading between
+	* sessions gets the last probed value rather than `null`. Passing it is what
+	* changed — it used to be copied forward from `previous` at every one of the
+	* four call sites and written by nobody, while `session.sampleRate` and
+	* `session.audioCodec` were in hand and only reaching a log line.
 	*/
-	publishIntercomState(talking) {
+	publishIntercomState(talking, ability) {
 		const previous = this.getCapSlice(intercomCapability);
 		this.setCapSlice(intercomCapability, {
 			talking,
 			lastSessionAt: talking ? Date.now() : previous?.lastSessionAt ?? null,
-			ability: previous?.ability ?? null
+			ability: ability ?? previous?.ability ?? null
 		});
 	}
 	registerIntercomIfSupported() {
@@ -45258,7 +45767,7 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 				});
 				try {
 					const opened = await this.intercomOrchestrator.start();
-					this.publishIntercomState(true);
+					this.publishIntercomState(true, this.intercomOrchestrator.ability ?? void 0);
 					return opened;
 				} catch (err) {
 					this.publishIntercomState(false);
@@ -45280,8 +45789,10 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 				if (deviceId !== this.id) throw new Error(`HikvisionCamera: intercom deviceId mismatch, expected ${this.id}, got ${deviceId}`);
 				if (this.disabled) throw new Error("Hikvision intercom: device is disabled — re-enable it before opening a talk session");
 				if (this.intercomRawSession) {
-					await this.intercomRawSession.session.stop().catch(() => {});
+					const previous = this.intercomRawSession;
 					this.intercomRawSession = null;
+					await previous.pcmTranscode.close();
+					await previous.session.stop().catch(() => {});
 				}
 				const session = new HikvisionIntercomSession({
 					client: this.ensureClient(),
@@ -45297,9 +45808,17 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 					id,
 					session,
 					lastSequenceNumber: -1,
-					opusDecode: null
+					opusDecode: null,
+					pcmTranscode: new TalkPcmTranscoder({
+						deviceId: this.id,
+						logger: this.ctx.logger,
+						resolveAudioCodec: () => this.resolveAudioCodecApi(),
+						targetSampleRate: session.sampleRate,
+						tag: `hikvision-intercom-pcm:${this.id}:${id}`,
+						feed: (pcm) => session.feedPcm(pcm)
+					})
 				};
-				this.publishIntercomState(true);
+				this.publishIntercomState(true, session.ability);
 				this.ctx.logger.info("intercom talk session opened", {
 					tags: { deviceId: this.id },
 					meta: {
@@ -45312,13 +45831,24 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 			},
 			pushTalkAudio: async ({ deviceId, audioBase64, codec, sampleRate, channels, sequenceNumber }) => {
 				if (deviceId !== this.id) return { accepted: false };
+				const wireCodec = codec ?? "s16le";
+				const note = (reason) => {
+					intercomFailureReport.noteTalkFrame(this.id, wireCodec, reason);
+				};
 				const active = this.intercomRawSession;
 				if (!active || !active.session.isOpen) return { accepted: false };
-				if (sequenceNumber <= active.lastSequenceNumber) return { accepted: false };
+				if (sequenceNumber <= active.lastSequenceNumber) {
+					note(REASON_TALK_OUT_OF_ORDER);
+					return { accepted: false };
+				}
 				const buf = Buffer.from(audioBase64, "base64");
-				if (buf.length === 0) return { accepted: false };
+				if (buf.length === 0) {
+					note(REASON_TALK_EMPTY);
+					return { accepted: false };
+				}
 				const ch = channels ?? 1;
 				if (ch !== 1) {
+					note(REASON_TALK_NOT_MONO);
 					this.ctx.logger.warn("intercom: dropping non-mono talk frame (Hikvision is mono-only)", {
 						tags: { deviceId: this.id },
 						meta: {
@@ -45328,9 +45858,9 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 					});
 					return { accepted: false };
 				}
-				const wireCodec = codec ?? "s16le";
 				if (wireCodec === "g711ulaw" || wireCodec === "g711alaw") {
 					if (wireCodec !== active.session.audioCodec) {
+						note(REASON_TALK_CODEC_UNSUPPORTED);
 						this.ctx.logger.warn("intercom: codec mismatch — wire codec is not what the camera negotiated, dropping frame", {
 							tags: { deviceId: this.id },
 							meta: {
@@ -45342,28 +45872,34 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 					}
 					active.lastSequenceNumber = sequenceNumber;
 					active.session.feedEncoded(buf);
+					note();
 					return { accepted: true };
 				}
 				if (wireCodec === "s16le") {
 					if (!sampleRate) {
+						note(REASON_TALK_NO_SAMPLE_RATE);
 						this.ctx.logger.warn("intercom: s16le push with no sampleRate — dropping (rate is ambiguous)", { tags: { deviceId: this.id } });
 						return { accepted: false };
 					}
 					if (sampleRate !== active.session.sampleRate) {
-						this.ctx.logger.warn("intercom: s16le sampleRate mismatch (PCM-only resample not implemented) — dropping", {
-							tags: { deviceId: this.id },
-							meta: {
-								wireRate: sampleRate,
-								cameraRate: active.session.sampleRate
-							}
+						const refusal = await active.pcmTranscode.feedResampled({
+							pcm: buf,
+							sourceSampleRate: sampleRate
 						});
-						return { accepted: false };
+						if (refusal !== null) {
+							note(refusal);
+							return { accepted: false };
+						}
+						active.lastSequenceNumber = sequenceNumber;
+						note();
+						return { accepted: true };
 					}
 					active.lastSequenceNumber = sequenceNumber;
 					active.session.feedPcm(buf);
+					note();
 					return { accepted: true };
 				}
-				if (wireCodec === "opus") {
+				if (wireCodec === "opus") try {
 					if (!active.opusDecode) {
 						const created = await this.resolveAudioCodecApi().createDecodeSession({
 							codec: "opus",
@@ -45406,8 +45942,20 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 						const pcmBuf = Buffer.from(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength);
 						if (pcmBuf.length > 0) active.session.feedPcm(pcmBuf);
 					}
+					note();
 					return { accepted: true };
+				} catch (err) {
+					note(REASON_TALK_OPUS_FAILED);
+					throw err;
 				}
+				note(REASON_TALK_CODEC_UNSUPPORTED);
+				this.ctx.logger.warn("intercom: no path onto the talk channel for this wire codec", {
+					tags: { deviceId: this.id },
+					meta: {
+						wireCodec,
+						cameraCodec: active.session.audioCodec
+					}
+				});
 				return { accepted: false };
 			},
 			endTalkSession: async ({ deviceId }) => {
@@ -45415,6 +45963,7 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 				const active = this.intercomRawSession;
 				if (!active) return;
 				this.intercomRawSession = null;
+				await active.pcmTranscode.close();
 				if (active.opusDecode) await this.resolveAudioCodecApi().closeSession({
 					sessionId: active.opusDecode.sessionId,
 					nodeId: active.opusDecode.nodeId
@@ -57617,7 +58166,12 @@ var HikvisionProviderAddon = class extends BaseDeviceProvider {
 		throw new Error(`Hikvision: ${reason}`);
 	}
 	async onInitialize() {
-		return await super.onInitialize();
+		const regs = await super.onInitialize();
+		regs.push({
+			capability: failureContributionCapability,
+			provider: { list: () => intercomFailureReport.list() }
+		});
+		return regs;
 	}
 	async supportsDiscovery() {
 		return true;