@camstack/addon-pipeline 1.2.139 → 1.2.140

package/dist/{dist-CTmOaCwF.mjs → dist-B25xMJDp.mjs}

@@ -9662,6 +9662,112 @@ var DecoderSessionConfigSchema = object({
 	*/
 	debug: boolean().optional()
 });
+/**
+* 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",
@@ -15030,6 +15136,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",
@@ -20083,6 +20316,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
 });
@@ -29779,6 +30026,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(),
 	/**
@@ -29837,7 +30091,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"
 });
@@ -32578,6 +32832,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",
@@ -35884,6 +36144,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.getFailureContributions": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"system.getLoadContributions": {
 		capName: "system",
 		capScope: "system",
@@ -39871,4 +40137,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { loadContributionCapability as $, string as $t, audioAnalysisCapability as A, BaseAddon as At, defineCustomActions as B, parseJsonUnknown as Bt, RATE_CONTROL_RELAXED as C, errMsg as Ct, RingBuffer as D, invocationFromEncodeProfile as Dt, RecordingConfigSchema as E, buildFfmpegArgs as Et, createHwAccelCache as F, hydrateSchema as Ft, egressTranscodeSharingKey as G, array as Gt, deriveDetailCropRect as H, selectAssignedProfileSlots as Ht, createLogChannelsProvider as I, isEvent as It, evaluateSensorEdge as J, lazy as Jt, egressTransportFromRequest as K, boolean as Kt, customAction as L, makeProfileBrokerId as Lt, audioKindId as M, DeviceFeature as Mt, batteryCapability as N, DeviceType as Nt, YAMNET_TO_MACRO as O, isSoftwareDecode as Ot, cameraStreamsCapability as P, createEvent as Pt, isFirstLevelMacroClass as Q, record as Qt, declareLogChannel as R, makeSourceBrokerId as Rt, PoolMemoryWatchdog as S, webrtcSessionCapability as St, RECORDING_EXPORT_MAX_READ_BYTES as T, Fmp4BoxSplitter as Tt, deriveRecordingMode as U, sleep as Ut, deriveBatteryPresence as V, parseProfileBrokerId as Vt, detectionPipelineCapability as W, _enum as Wt, hfModelUrl as X, number as Xt, evaluateZoneRules as Y, literal as Yt, inferModelProvider as Z, object as Zt, ExportRecordSchema as _, resolveRecordingProfiles as _t, COCO_80_LABELS as a, parseProcStatus as at, NativeLeaseSettingsSchema as b, streamBrokerCapability as bt, DEFAULT_CLUSTER_STEP_MODELS as c, pickDetailCropConvention as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, pipelineRunnerCapability as dt, union as en, logChannelsCapability as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, recordingCapability as ft, EncodeProfileSchema as g, resolvePoolMemoryPolicy as gt, EVENT_PAD_MS as h, resolveEgressDecodeHwAccel as ht, BatteryStatusSchema as i, overlayClusterStepSettings as it, audioAnalyzerCapability as j, CAM_PROFILE_ORDER as jt, addonWidgetsSourceCapability as k, BOOT_RECOVERY_BACKOFF_MS as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, pickNativeLeaseOverride as lt, DEVICE_BACKEND_TO_FORMAT as m, resolveClusterStepModelId as mt, AUDIO_BACKEND_CHOICES as n, maskUrlCredentials as nt, COCO_TO_MACRO as o, pickClusterStepModels as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, recordingExportCapability as pt, enumerateInferenceDevices as q, discriminatedUnion as qt, AUDIO_MACRO_LABELS as r, motionDetectionCapability as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, pickClusterStepSettings as st, APPLE_SA_TO_MACRO as t, EventCategory as tn, mapAudioLabelToMacro as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, pipelineExecutorCapability as ut, HF_BASE_URL as v, runtimeDevices as vt, RATE_CONTROL_TIGHT as w, AUDIO_PRESETS as wt, OpsLogEntrySchema as x, supportedRuntimes as xt, NativeLeaseAdmissionSchema as y, storageEvictableCapability as yt, defaultDeviceFor as z, nodePin as zt };
+export { inferModelProvider as $, object as $t, addonWidgetsSourceCapability as A, isSoftwareDecode as At, defaultDeviceFor as B, makeSourceBrokerId as Bt, PoolMemoryWatchdog as C, supportedRuntimes as Ct, RecordingConfigSchema as D, Fmp4BoxSplitter as Dt, RECORDING_EXPORT_MAX_READ_BYTES as E, AUDIO_PRESETS as Et, cameraStreamsCapability as F, DeviceType as Ft, detectionPipelineCapability as G, sleep as Gt, deriveBatteryPresence as H, parseJsonUnknown as Ht, createHwAccelCache as I, createEvent as It, enumerateInferenceDevices as J, boolean as Jt, egressTranscodeSharingKey as K, _enum as Kt, createLogChannelsProvider as L, hydrateSchema as Lt, audioAnalyzerCapability as M, BaseAddon as Mt, audioKindId as N, CAM_PROFILE_ORDER as Nt, RingBuffer as O, buildFfmpegArgs as Ot, batteryCapability as P, DeviceFeature as Pt, hfModelUrl as Q, number as Qt, customAction as R, isEvent as Rt, OpsLogEntrySchema as S, streamBrokerCapability as St, RATE_CONTROL_TIGHT as T, errMsg as Tt, deriveDetailCropRect as U, parseProfileBrokerId as Ut, defineCustomActions as V, nodePin as Vt, deriveRecordingMode as W, selectAssignedProfileSlots as Wt, evaluateZoneRules as X, lazy as Xt, evaluateSensorEdge as Y, discriminatedUnion as Yt, failureContributionCapability as Z, literal as Zt, ExportRecordSchema as _, resolveEgressDecodeHwAccel as _t, COCO_80_LABELS as a, motionDetectionCapability as at, NativeLeaseAdmissionSchema as b, runtimeDevices as bt, DEFAULT_CLUSTER_STEP_MODELS as c, pickClusterStepModels as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, pickNativeLeaseOverride as dt, record as en, isFirstLevelMacroClass as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, pipelineExecutorCapability as ft, EncodeProfileSchema as g, resolveClusterStepModelId as gt, EVENT_PAD_MS as h, recordingExportCapability as ht, BatteryStatusSchema as i, maskUrlCredentials as it, audioAnalysisCapability as j, BOOT_RECOVERY_BACKOFF_MS as jt, YAMNET_TO_MACRO as k, invocationFromEncodeProfile as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, pickClusterStepSettings as lt, DEVICE_BACKEND_TO_FORMAT as m, recordingCapability as mt, AUDIO_BACKEND_CHOICES as n, union as nn, logChannelsCapability as nt, COCO_TO_MACRO as o, overlayClusterStepSettings as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, pipelineRunnerCapability as pt, egressTransportFromRequest as q, array as qt, AUDIO_MACRO_LABELS as r, EventCategory as rn, mapAudioLabelToMacro as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, parseProcStatus as st, APPLE_SA_TO_MACRO as t, string as tn, loadContributionCapability as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, pickDetailCropConvention as ut, FailureCounters as v, resolvePoolMemoryPolicy as vt, RATE_CONTROL_RELAXED as w, webrtcSessionCapability as wt, NativeLeaseSettingsSchema as x, storageEvictableCapability as xt, HF_BASE_URL as y, resolveRecordingProfiles as yt, declareLogChannel as z, makeProfileBrokerId as zt };

package/dist/{event-loop-stall-monitor-CoM21UjL.js → event-loop-stall-monitor-BQeD-JuB.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-WUZH-lAM.js");
+const require_dist = require("./dist-3bEUjzHN.js");
 let node_crypto = require("node:crypto");
 let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/registry/model-catalogs.ts

package/dist/{event-loop-stall-monitor-BMtR9qZR.mjs → event-loop-stall-monitor-CrWg3jrh.mjs}

@@ -1,4 +1,4 @@
-import { M as audioKindId, X as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-CTmOaCwF.mjs";
+import { N as audioKindId, Q as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-B25xMJDp.mjs";
 import { randomUUID } from "node:crypto";
 import { PerformanceObserver } from "node:perf_hooks";
 //#region src/detection-pipeline/registry/model-catalogs.ts

package/dist/{lazy-sharp-1WF7ZnxZ.js → lazy-sharp-buaVXzJ6.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-WUZH-lAM.js");
+const require_dist = require("./dist-3bEUjzHN.js");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
 let node_url = require("node:url");

package/dist/motion-wasm/index.js

@@ -2,8 +2,8 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-WUZH-lAM.js");
-const require_lazy_sharp = require("../lazy-sharp-1WF7ZnxZ.js");
+const require_dist = require("../dist-3bEUjzHN.js");
+const require_lazy_sharp = require("../lazy-sharp-buaVXzJ6.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { At as BaseAddon, Ft as hydrateSchema, Nt as DeviceType, Y as evaluateZoneRules, rt as motionDetectionCapability } from "../dist-CTmOaCwF.mjs";
+import { Ft as DeviceType, Lt as hydrateSchema, Mt as BaseAddon, X as evaluateZoneRules, at as motionDetectionCapability } from "../dist-B25xMJDp.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/{node-CQcgxO8l.mjs → node-CFEV-qgx.mjs}

@@ -1,4 +1,4 @@
-import { Ct as errMsg, Et as buildFfmpegArgs, Ot as isSoftwareDecode, Tt as Fmp4BoxSplitter } from "./dist-CTmOaCwF.mjs";
+import { At as isSoftwareDecode, Dt as Fmp4BoxSplitter, Ot as buildFfmpegArgs, Tt as errMsg } from "./dist-B25xMJDp.mjs";
 import { randomUUID } from "node:crypto";
 import "node:fs";
 import "node:path";

package/dist/{node-BAo2ivVu.js → node-Cn9gEOs4.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-WUZH-lAM.js");
+const require_dist = require("./dist-3bEUjzHN.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);

package/dist/pipeline-runner/index.js

@@ -2,12 +2,12 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-WUZH-lAM.js");
-const require_node = require("../node-BAo2ivVu.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-CoM21UjL.js");
-const require_worker_protocol = require("../worker-protocol-C-0LYdSt.js");
+const require_dist = require("../dist-3bEUjzHN.js");
+const require_node = require("../node-Cn9gEOs4.js");
+const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-BQeD-JuB.js");
+const require_worker_protocol = require("../worker-protocol-CxvZ6FP4.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-1WF7ZnxZ.js");
+const require_lazy_sharp = require("../lazy-sharp-buaVXzJ6.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 let node_child_process = require("node:child_process");
@@ -3652,6 +3652,74 @@ function packageZoneUnion(polygons) {
 	};
 }
 //#endregion
+//#region src/pipeline-runner/failure-report.ts
+/**
+* What `pipeline-runner` reports through `failure-contribution` — the inference
+* deadline, per camera, with the frames that made it as the denominator.
+*
+* ## The number that was never divided
+*
+* ~120 `inference timed out — permit released, result discarded` lines in six
+* hours across seven cameras, on 2026-08-28, never investigated. The line has
+* carried `tags: { deviceId }` for a while, so the count per camera was always
+* available; what was not available was the number to divide it by. 120
+* timeouts out of 120 000 admitted frames and 120 out of 1 200 are opposite
+* findings and produce identical log volume.
+*
+* So the counter takes BOTH outcomes of the same await, from the same place in
+* `awaitInferenceBounded`. A success counted anywhere else would eventually
+* drift from the failure and turn the ratio into fiction.
+*
+* ## Why there is no `variant` yet
+*
+* `failure-contribution` has a `variant` slot exactly so "which camera AND
+* which model" is one read, and the operator asked for it. The runner cannot
+* fill it honestly: `awaitInferenceBounded` wraps
+* `config.processFrame(deviceId, frameInput, executorHandle)`, which runs the
+* camera's WHOLE pipeline graph behind one deadline. Nothing at this seam knows
+* which step was still running when the 20 s expired — `CameraRegistration`
+* carries fps and mode, not models.
+*
+* Naming the step means the executor attributing the deadline to the step that
+* held it, and reporting THAT. Emitting a `variant` the runner guessed (the
+* camera's configured graph id, say) would be worse than leaving it absent: it
+* would look like an attribution and be a label. Absent, never invented — the
+* same rule `load-contribution` states for a measurement nobody made.
+*/
+/** One bounded inference deadline per admitted detection frame. */
+var FAMILY_INFERENCE = "inference";
+/** The call did not return inside `inferenceTimeoutMs`. */
+var REASON_INFERENCE_TIMEOUT = "timeout";
+/**
+* The runner's `failure-contribution` counters.
+*
+* One instance per runner process, read (never drained) by the provider.
+*/
+var RunnerFailureReport = class {
+	now;
+	counters;
+	constructor(now = Date.now, counters = new require_dist.FailureCounters()) {
+		this.now = now;
+		this.counters = counters;
+	}
+	/** One bounded inference call. `reason` absent = it returned in time. */
+	noteInference(deviceId, reason) {
+		this.counters.note({
+			deviceId,
+			family: FAMILY_INFERENCE,
+			...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();
+	}
+};
+//#endregion
 //#region src/pipeline-runner/frame-governor.ts
 var FrameGovernor = class {
 	config;
@@ -4716,6 +4784,7 @@ var PipelineRunner = class {
 			if (outcome === TIMED_OUT) {
 				release();
 				this.inflightTimeouts += 1;
+				this.config.noteInferenceOutcome?.(deviceId, REASON_INFERENCE_TIMEOUT);
 				this.logger?.warn("inference timed out — permit released, result discarded", {
 					tags: { deviceId },
 					meta: {
@@ -4738,7 +4807,7 @@ var PipelineRunner = class {
 					});
 				};
 				inflight.then(() => noteSettled("resolved"), () => noteSettled("rejected"));
-			}
+			} else this.config.noteInferenceOutcome?.(deviceId);
 			return outcome;
 		} finally {
 			if (timer !== null) clearTimeout(timer);
@@ -5269,6 +5338,13 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	costRegistry = new require_node.ChildCostRegistry();
 	/**
+	* Per-camera inference-deadline counters reported through
+	* `failure-contribution`. Bounded, cumulative, and read (never drained) by
+	* the provider. Constructed eagerly: created on the first timeout it would
+	* have no denominator for everything that already succeeded.
+	*/
+	failureReport = new RunnerFailureReport();
+	/**
 	* Per-runner (per-node) decode-worker SPAWN-CONCURRENCY GATE (P5). A single
 	* counting semaphore every session-decode fork (detection + motion, all
 	* cameras on this node) passes through, sized to
@@ -5519,7 +5595,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			logger: this.ctx.logger,
 			onOccupancyRecheck: (deviceId, frames) => {
 				this.enqueueOccupancyBurst(deviceId, frames);
-			}
+			},
+			noteInferenceOutcome: (deviceId, reason) => this.failureReport.noteInference(deviceId, reason)
 		});
 		this.spawnGate = new Semaphore(Math.max(1, this.config.maxConcurrentDecodeSpawns));
 		this.liveWorkers = new LiveDecodeWorkerAdmission({
@@ -5567,13 +5644,20 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		});
 		this.metricsSnapshotTimer = setInterval(() => this.emitMetricsSnapshot(), METRICS_SNAPSHOT_INTERVAL_MS);
 		return {
-			providers: [{
-				capability: require_dist.pipelineRunnerCapability,
-				provider: this
-			}, {
-				capability: require_dist.loadContributionCapability,
-				provider: { list: () => this.costRegistry.contributions() }
-			}],
+			providers: [
+				{
+					capability: require_dist.pipelineRunnerCapability,
+					provider: this
+				},
+				{
+					capability: require_dist.loadContributionCapability,
+					provider: { list: () => this.costRegistry.contributions() }
+				},
+				{
+					capability: require_dist.failureContributionCapability,
+					provider: { list: () => this.failureReport.list() }
+				}
+			],
 			customActions: pipelineRunnerBenchActions,
 			actionHandlers: {
 				cacheBenchFrame: async (input) => this.cacheBenchFrame(input),