@camstack/addon-provider-hikvision 1.2.45 → 1.2.47

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",
@@ -13650,6 +13756,133 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 	limit: number().optional(),
 	tags: record(string(), string()).optional()
 }), array(LogEntrySchema).readonly());
+/**
+* `failure-contribution` — the capability an addon reports its OWN losses
+* through, per camera, with the denominator attached. It stores nothing.
+*
+* ## The twin of `load-contribution`, and why it is a twin and not a field
+*
+* `load-contribution` answers *what did this camera COST*. This answers *what
+* did this camera LOSE*. The reporting discipline is identical and deliberately
+* copied: the contributor reports what it already knows, hub-main adds only
+* `addonId`, nothing needs global knowledge, and there is no central list for
+* somebody to forget to edit.
+*
+* They are not merged, because their invariants are opposites:
+*
+*  - a `load-contribution` measurement is **absent, never zero** — a zero would
+*    claim a camera cost nothing, which is a measurement nobody made;
+*  - a `failure-contribution` zero is the **most valuable value on the
+*    surface** — `attempts: 400, succeeded: 400` is the proof a fix landed,
+*    and it is exactly what an absent entry cannot say.
+*
+* Putting a loss counter on a cost entry would also break the reconciliation
+* that gives `load-contribution` its point: contributions are subtracted from
+* `metrics.node-processes-snapshot` to find processes nobody claims. A failure
+* has no process.
+*
+* ## Why not a log line, since the counters already exist
+*
+* Several of these paths already counted themselves — `CaptureScheduler`'s
+* per-device window, `KeyFrameCaptureLog`, `bumpCropMetric`. Every one of them
+* ends in a log line, and a log line is the thing the operator asked to stop
+* needing: *"possiamo armare questi errori intanto? Così al prossimo giro
+* ricontrolliamo tutti questi punti"*. Reading them meant grepping Loki and
+* hand-correlating timestamps, which is how a 22% thumbnail gap and a 3-hour
+* media blackout were both diagnosed. The counters stay; this is where they can
+* be READ.
+*
+* ## The rate is served with its denominator or not at all
+*
+* Every entry carries `attempts` and `succeeded`. A miss count alone is
+* unreadable: on 2026-08-28 the enrichment-crop miss count read as "35x worse
+* than yesterday" and was **flat across twelve hours** once divided by the
+* successes on the same path. A surface that publishes only the numerator
+* reproduces that mistake on every read.
+*
+* ## Shape
+*
+* Copied from `load-contribution.cap.ts` (`mode: 'collection'`,
+* `internal: true`, `mount: { kind: 'skip' }`): no tRPC route of its own and no
+* generated hooks, while `addons.listCapabilityProviders` still enumerates it
+* and the hub's `CapabilityRegistry` still holds an RPC proxy per provider — so
+* a forked runner's entries reach hub-main over transport that already exists.
+* No new UDS message, no second registry (D3). The operator reads the assembled
+* result through `system.getFailureContributions`.
+*/
+var FailureReasonCountSchema = object({
+	/**
+	* Why the attempt did not land, in the contributor's own vocabulary —
+	* `worker-lease-gone`, `queue-overflow`, `timeout`, `empty-read`. The same
+	* strings that already appear in this repo's logs and, where one exists, the
+	* same string the per-track `previewMissReason` records (D276): a second
+	* vocabulary for the same loss would make the row and the counter
+	* un-joinable.
+	*/
+	reason: string(),
+	count: number().int().nonnegative()
+});
+var FailureContributionSchema = object({
+	/**
+	* The failing path — `enrichment-crop`, `inference`, `plate-ocr`,
+	* `person-over-vehicle`. Free text, for the reason `load-contribution` keeps
+	* `unit` free: the families are owned by different addons and a shared enum
+	* is a central list that rots invisibly.
+	*/
+	family: string(),
+	/**
+	* The NUMERIC device id — the same value every log line carries as
+	* `tags.deviceId`. Never nullable and never absent: a contributor that
+	* cannot name the camera must not emit the entry, because a fleet total
+	* cannot answer the only question anybody asks of this surface.
+	*/
+	deviceId: number().int().positive(),
+	/**
+	* A second dimension inside the family: the model / step id for an inference
+	* timeout, so "which camera AND which model" is one read. Absent when the
+	* family has a single variant.
+	*/
+	variant: string().optional(),
+	/**
+	* Epoch ms this counter started — the INCARNATION MARKER. A consumer
+	* differencing two reads must drop the interval when it changes, because the
+	* counter restarted from zero in a respawned runner. Same discipline as
+	* `LoadContribution.startedAtMs`.
+	*/
+	sinceMs: number(),
+	/** Epoch ms it was read. `atMs - sinceMs` is the interval this covers. */
+	atMs: number(),
+	/**
+	* THE DENOMINATOR — every attempt on this path for this camera in the
+	* window. A failure count published without it is the mistake this schema
+	* exists to make impossible.
+	*/
+	attempts: number().int().nonnegative(),
+	/** Attempts that landed. `attempts - succeeded` is the loss. */
+	succeeded: number().int().nonnegative(),
+	/** The loss, partitioned. Sums to `attempts - succeeded`. */
+	reasons: array(FailureReasonCountSchema).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",
@@ -18240,6 +18473,20 @@ var TrackSchema = object({
 	* `=== true` and render nothing otherwise — never infer "no rider".
 	*/
 	hasRider: boolean().optional(),
+	/**
+	* WHY this track ended without a NATIVE best-shot tile
+	* ([D276](../decisions/adr-0276-a-stand-in-tile-is-provisional-and-a-close-says-why.md)) —
+	* a composed token line (`no-key-frame capture=keyframe:native-missx4`,
+	* `derive-returned-null tile=standin`, …) written at close and CLEARED by
+	* the late-keyFrame upgrade when a native tile lands after all. The
+	* operator-facing answer to "perché manca l'immagine?" on a track whose
+	* tile is a face/plate stand-in, a raster crop, or an icon.
+	*
+	* **Absent ≠ "missed silently"**: a row written before the column, a hub
+	* that predates the field, and every track whose tile landed native all
+	* omit it. Render nothing when absent.
+	*/
+	previewMissReason: string().optional(),
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
@@ -29850,6 +30097,13 @@ var LoggingSettingsPatchSchema = object({
 * anyone but its owner.
 */
 var ReportedLoadContributionSchema = LoadContributionSchema.extend({ addonId: string() });
+/**
+* One per-camera failure counter, plus WHO reported it.
+*
+* Same rule as {@link ReportedLoadContributionSchema}: `addonId` is stamped by
+* the hub as it enumerates providers, never by the contributor.
+*/
+var ReportedFailureContributionSchema = FailureContributionSchema.extend({ addonId: string() });
 var GetLoggingSettingsInputSchema = object({
 	scopeNodeId: string().optional(),
 	/**
@@ -29908,7 +30162,7 @@ method(_void(), FeatureManifestSchema), method(_void(), HealthStatusSchema), met
 }), method(_void(), SiteLocationStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), RequestCensusStatusSchema, { auth: "admin" }), method(_void(), array(ReportedLoadContributionSchema).readonly(), { auth: "admin" }), method(GetLoggingSettingsInputSchema, LoggingSettingsStateSchema, { auth: "admin" }), method(SetLoggingSettingsInputSchema, LoggingSettingsStateSchema, {
+}), method(_void(), RequestCensusStatusSchema, { auth: "admin" }), method(_void(), array(ReportedLoadContributionSchema).readonly(), { auth: "admin" }), method(_void(), array(ReportedFailureContributionSchema).readonly(), { auth: "admin" }), method(GetLoggingSettingsInputSchema, LoggingSettingsStateSchema, { auth: "admin" }), method(SetLoggingSettingsInputSchema, LoggingSettingsStateSchema, {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -34131,6 +34385,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"failureContribution.list": {
+		capName: "failure-contribution",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"fanControl.setDirection": {
 		capName: "fan-control",
 		capScope: "device",
@@ -37437,6 +37697,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.getFailureContributions": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"system.getLoadContributions": {
 		capName: "system",
 		capScope: "system",
@@ -43449,6 +43715,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
@@ -43517,6 +43792,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";
@@ -43575,7 +43880,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;
@@ -43757,6 +44062,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;
@@ -43774,6 +44163,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
@@ -44035,6 +44432,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() {
@@ -45082,13 +45666,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() {
@@ -45117,7 +45708,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);
@@ -45139,8 +45730,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(),
@@ -45156,9 +45749,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: {
@@ -45171,13 +45772,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: {
@@ -45187,9 +45799,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: {
@@ -45201,28 +45813,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",
@@ -45265,8 +45883,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 }) => {
@@ -45274,6 +45904,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
@@ -57476,7 +58107,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;