@camstack/addon-provider-velux 0.2.38 → 0.2.41

package/dist/addon.js

@@ -13467,6 +13467,114 @@ 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()
+});
+method(_void(), array(FailureContributionSchema).readonly());
 var LoadContributionSchema = object({
 	role: _enum([
 		"decode",
@@ -13774,6 +13882,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() });
@@ -13837,6 +13989,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.
@@ -18057,6 +18224,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
 });
@@ -27518,10 +27699,10 @@ DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceI
 * 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(),
@@ -29232,6 +29413,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(),
 	/**
@@ -29290,7 +29478,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"
 });
@@ -33280,6 +33468,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",
@@ -36586,6 +36780,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.getFailureContributions": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"system.getLoadContributions": {
 		capName: "system",
 		capScope: "system",

package/dist/addon.mjs

@@ -13466,6 +13466,114 @@ 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()
+});
+method(_void(), array(FailureContributionSchema).readonly());
 var LoadContributionSchema = object({
 	role: _enum([
 		"decode",
@@ -13773,6 +13881,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() });
@@ -13836,6 +13988,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.
@@ -18056,6 +18223,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
 });
@@ -27517,10 +27698,10 @@ DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceI
 * 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(),
@@ -29231,6 +29412,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(),
 	/**
@@ -29289,7 +29477,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"
 });
@@ -33279,6 +33467,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",
@@ -36585,6 +36779,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.getFailureContributions": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"system.getLoadContributions": {
 		capName: "system",
 		capScope: "system",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-provider-velux",
-  "version": "0.2.38",
+  "version": "0.2.41",
   "description": "Velux KLF-200 device-provider addon for CamStack — local-gateway window + shutter covers (positional, no tilt)",
   "keywords": [
     "camstack",