@camstack/addon-pipeline 1.2.135 → 1.2.137

package/dist/{addon-utils-CKf8kbwh.js → addon-utils-C6b5Tnia.js}

@@ -1,9 +1,9 @@
-const require_dist = require("./dist-BzLiQ8Ue.js");
+const require_dist = require("./dist-4EMKvxCp.js");
 require("node:crypto");
-let node_path = require("node:path");
-node_path = require_dist.__toESM(node_path, 1);
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_dist.__toESM(node_path, 1);
 let node_util = require("node:util");
 let node_zlib = require("node:zlib");
 //#region ../system/dist/file-data-plane-BhKdxJgf.mjs

package/dist/audio-analyzer/index.js

@@ -2,13 +2,13 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BzLiQ8Ue.js");
-const require_process_memory = require("../process-memory-CZK3D3kM.js");
-const require_addon_utils = require("../addon-utils-CKf8kbwh.js");
-let node_path = require("node:path");
-node_path = require_dist.__toESM(node_path);
+const require_dist = require("../dist-4EMKvxCp.js");
+const require_process_memory = require("../process-memory-C3084DOt.js");
+const require_addon_utils = require("../addon-utils-C6b5Tnia.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_dist.__toESM(node_path);
 //#region src/audio-analyzer/audio-pipeline.ts
 /**
 * Create the appropriate audio pipeline.

package/dist/audio-analyzer/index.mjs

@@ -1,9 +1,9 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { A as audioAnalysisCapability, Nt as hydrateSchema, Ot as BaseAddon, S as PoolMemoryWatchdog, St as errMsg, et as mapAudioLabelToMacro, ht as resolvePoolMemoryPolicy, j as audioAnalyzerCapability, n as AUDIO_BACKEND_CHOICES, s as DEFAULT_AUDIO_ANALYZER_CONFIG, v as HF_BASE_URL } from "../dist-C1dXLLQq.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-CaEwi5Cd.mjs";
-import { i as downloadFile } from "../addon-utils-CgBCF-mE.mjs";
-import * as path$1 from "node:path";
+import { A as audioAnalysisCapability, Ct as errMsg, Pt as hydrateSchema, S as PoolMemoryWatchdog, gt as resolvePoolMemoryPolicy, j as audioAnalyzerCapability, kt as BaseAddon, n as AUDIO_BACKEND_CHOICES, s as DEFAULT_AUDIO_ANALYZER_CONFIG, tt as mapAudioLabelToMacro, v as HF_BASE_URL } from "../dist-g0Or5_pR.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-DmrHWybb.mjs";
+import { i as downloadFile } from "../addon-utils-C8KTuPdE.mjs";
 import * as fs from "node:fs";
+import * as path$1 from "node:path";
 //#region src/audio-analyzer/audio-pipeline.ts
 /**
 * Create the appropriate audio pipeline.

package/dist/detection-pipeline/index.js

@@ -2,20 +2,21 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BzLiQ8Ue.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DjV4Bow7.js");
-const require_lazy_sharp = require("../lazy-sharp-DxWmhTqk.js");
-const require_process_memory = require("../process-memory-CZK3D3kM.js");
-const require_addon_utils = require("../addon-utils-CKf8kbwh.js");
-let sharp = require("sharp");
-sharp = require_dist.__toESM(sharp);
-let node_child_process = require("node:child_process");
+const require_dist = require("../dist-4EMKvxCp.js");
+const require_node = require("../node-BOHn8gpk.js");
+const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DDm07Ei6.js");
+const require_lazy_sharp = require("../lazy-sharp-BlA9PxWk.js");
+const require_process_memory = require("../process-memory-C3084DOt.js");
+const require_addon_utils = require("../addon-utils-C6b5Tnia.js");
+let node_fs = require("node:fs");
+node_fs = require_dist.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
+let node_child_process = require("node:child_process");
+let sharp = require("sharp");
+sharp = require_dist.__toESM(sharp);
 let node_os = require("node:os");
 node_os = require_dist.__toESM(node_os);
-let node_fs = require("node:fs");
-node_fs = require_dist.__toESM(node_fs);
 //#region src/detection-pipeline/runtimes.ts
 var KNOWN_PLATFORMS = [
 	"darwin",
@@ -6313,6 +6314,36 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* never mutates shared state, so concurrent multi-device sessions don't race.
 	*/
 	factoriesByDevice = /* @__PURE__ */ new Map();
+	/**
+	* This addon's `load-contribution`: the shared inference pool, DECLARING
+	* that it cannot be attributed to a camera.
+	*
+	* The renunciation is data, not a deduction. One python process per (node,
+	* runtime, hardware device) serves every camera on the node, so no
+	* `deviceId` is true of it — `deviceId: null` and
+	* `attribution: 'unattributable'` say exactly that, and a consumer that
+	* plots per-camera load must exclude it rather than apportion it. The pool's
+	* pids are included so the node's process snapshot can mark those processes
+	* CLAIMED-but-shared instead of unknown; without them a reader cannot tell
+	* "shared cost, reported" from "process nobody knows about".
+	*
+	* Per-camera inference MILLISECONDS are counted elsewhere and are a
+	* different quantity — how much of the pool a camera asked for, never how
+	* many CPU seconds it cost. They are deliberately not smuggled in here.
+	*/
+	async loadContributions() {
+		const factories = [...this.engineFactory === null ? [] : [["default", this.engineFactory]], ...this.factoriesByDevice.entries()];
+		const out = [];
+		for (const [deviceKey, factory] of factories) for (const pid of factory.getPoolPids()) out.push({
+			role: "detection",
+			deviceId: null,
+			attribution: "unattributable",
+			unit: `inference pool ${deviceKey}`,
+			pid,
+			...await require_node.readProcessCost(pid)
+		});
+		return out;
+	}
 	executor = null;
 	currentSteps = null;
 	currentEngine;
@@ -9884,13 +9915,20 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		await this.provider.warmPool();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
 		this.lastAppliedOverride = this.resolveOperatorOverride();
-		return [{
-			capability: require_dist.pipelineExecutorCapability,
-			provider: this.provider
-		}, {
-			capability: require_dist.detectionPipelineCapability,
-			provider: this.provider
-		}];
+		return [
+			{
+				capability: require_dist.pipelineExecutorCapability,
+				provider: this.provider
+			},
+			{
+				capability: require_dist.detectionPipelineCapability,
+				provider: this.provider
+			},
+			{
+				capability: require_dist.loadContributionCapability,
+				provider: { list: async () => await this.provider?.loadContributions() ?? [] }
+			}
+		];
 	}
 	/**
 	* Emit a single `pipeline.engine-metrics-snapshot` event with the

package/dist/detection-pipeline/index.mjs

@@ -1,14 +1,15 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { $t as EventCategory, Lt as nodePin, Mt as createEvent, Nt as hydrateSchema, O as YAMNET_TO_MACRO, Ot as BaseAddon, Qt as union, Rt as parseJsonUnknown, S as PoolMemoryWatchdog, St as errMsg, Ut as array, Vt as sleep, W as detectionPipelineCapability, Y as evaluateZoneRules, Yt as object, Z as inferModelProvider, Zt as string, _t as runtimeDevices$1, at as pickClusterStepModels, bt as supportedRuntimes$1, c as DEFAULT_CLUSTER_STEP_MODELS, ht as resolvePoolMemoryPolicy, l as DEFAULT_CLUSTER_STEP_SETTINGS, lt as pipelineExecutorCapability, m as DEVICE_BACKEND_TO_FORMAT, ot as pickClusterStepSettings, pt as resolveClusterStepModelId, q as enumerateInferenceDevices, rt as overlayClusterStepSettings, t as APPLE_SA_TO_MACRO, z as defaultDeviceFor$1 } from "../dist-C1dXLLQq.mjs";
-import { a as ALL_PIPELINE_STEPS, c as getDefaultModelForFormatFromDef, d as resolveModelForFormat, f as landmarkPrecisionVerdict, l as getStep, n as startEventLoopStallMonitor, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as getStepDefinition } from "../event-loop-stall-monitor-CU-xxX5c.mjs";
-import { t as getSharp } from "../lazy-sharp-BtT5x-qP.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-CaEwi5Cd.mjs";
-import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../addon-utils-CgBCF-mE.mjs";
-import sharp from "sharp";
-import { spawn } from "node:child_process";
+import { $ as loadContributionCapability, $t as union, Ct as errMsg, Ht as sleep, Nt as createEvent, O as YAMNET_TO_MACRO, Pt as hydrateSchema, Qt as string, Rt as nodePin, S as PoolMemoryWatchdog, W as detectionPipelineCapability, Wt as array, Xt as object, Y as evaluateZoneRules, Z as inferModelProvider, c as DEFAULT_CLUSTER_STEP_MODELS, en as EventCategory, gt as resolvePoolMemoryPolicy, it as overlayClusterStepSettings, kt as BaseAddon, l as DEFAULT_CLUSTER_STEP_SETTINGS, m as DEVICE_BACKEND_TO_FORMAT, mt as resolveClusterStepModelId, ot as pickClusterStepModels, q as enumerateInferenceDevices, st as pickClusterStepSettings, t as APPLE_SA_TO_MACRO, ut as pipelineExecutorCapability, vt as runtimeDevices$1, xt as supportedRuntimes$1, z as defaultDeviceFor$1, zt as parseJsonUnknown } from "../dist-g0Or5_pR.mjs";
+import { a as readProcessCost } from "../node-Bo1g8hLO.mjs";
+import { a as ALL_PIPELINE_STEPS, c as getDefaultModelForFormatFromDef, d as resolveModelForFormat, f as landmarkPrecisionVerdict, l as getStep, n as startEventLoopStallMonitor, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as getStepDefinition } from "../event-loop-stall-monitor-CskL9Lgu.mjs";
+import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-DmrHWybb.mjs";
+import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../addon-utils-C8KTuPdE.mjs";
+import * as fs from "node:fs";
 import * as path$1 from "node:path";
+import { spawn } from "node:child_process";
+import sharp from "sharp";
 import * as os from "node:os";
-import * as fs from "node:fs";
 //#region src/detection-pipeline/runtimes.ts
 var KNOWN_PLATFORMS = [
 	"darwin",
@@ -6306,6 +6307,36 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* never mutates shared state, so concurrent multi-device sessions don't race.
 	*/
 	factoriesByDevice = /* @__PURE__ */ new Map();
+	/**
+	* This addon's `load-contribution`: the shared inference pool, DECLARING
+	* that it cannot be attributed to a camera.
+	*
+	* The renunciation is data, not a deduction. One python process per (node,
+	* runtime, hardware device) serves every camera on the node, so no
+	* `deviceId` is true of it — `deviceId: null` and
+	* `attribution: 'unattributable'` say exactly that, and a consumer that
+	* plots per-camera load must exclude it rather than apportion it. The pool's
+	* pids are included so the node's process snapshot can mark those processes
+	* CLAIMED-but-shared instead of unknown; without them a reader cannot tell
+	* "shared cost, reported" from "process nobody knows about".
+	*
+	* Per-camera inference MILLISECONDS are counted elsewhere and are a
+	* different quantity — how much of the pool a camera asked for, never how
+	* many CPU seconds it cost. They are deliberately not smuggled in here.
+	*/
+	async loadContributions() {
+		const factories = [...this.engineFactory === null ? [] : [["default", this.engineFactory]], ...this.factoriesByDevice.entries()];
+		const out = [];
+		for (const [deviceKey, factory] of factories) for (const pid of factory.getPoolPids()) out.push({
+			role: "detection",
+			deviceId: null,
+			attribution: "unattributable",
+			unit: `inference pool ${deviceKey}`,
+			pid,
+			...await readProcessCost(pid)
+		});
+		return out;
+	}
 	executor = null;
 	currentSteps = null;
 	currentEngine;
@@ -9877,13 +9908,20 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		await this.provider.warmPool();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
 		this.lastAppliedOverride = this.resolveOperatorOverride();
-		return [{
-			capability: pipelineExecutorCapability,
-			provider: this.provider
-		}, {
-			capability: detectionPipelineCapability,
-			provider: this.provider
-		}];
+		return [
+			{
+				capability: pipelineExecutorCapability,
+				provider: this.provider
+			},
+			{
+				capability: detectionPipelineCapability,
+				provider: this.provider
+			},
+			{
+				capability: loadContributionCapability,
+				provider: { list: async () => await this.provider?.loadContributions() ?? [] }
+			}
+		];
 	}
 	/**
 	* Emit a single `pipeline.engine-metrics-snapshot` event with the

package/dist/{dist-BzLiQ8Ue.js → dist-4EMKvxCp.js}

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let node_crypto = require("node:crypto");
-//#region ../types/dist/event-category-CIa_iT6b.mjs
+//#region ../types/dist/event-category-BZL-fdNj.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -459,7 +459,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["MetricsNodeResourcesSnapshot"] = "metrics.node-resources-snapshot";
 	/**
 	* Periodic per-node process-tree snapshot (camstack-related pids
-	* with ghost / managed / root classification). Emitted ~0.2 Hz by
+	* with root / managed / system classification). Emitted ~0.2 Hz by
 	* the metrics-provider addon. Drives the Cluster → Processes tab
 	* without polling `metricsProvider.listNodeProcesses`.
 	*/
@@ -12891,6 +12891,19 @@ var SettingsRecordSchema = object({
 	data: record(string(), unknown())
 });
 /**
+* One record of a BULK insert — {@link SettingsRecordSchema} with the id made
+* optional.
+*
+* A separate schema rather than loosening the shared one: every other method
+* on this cap addresses a row BY its id, and making that field optional
+* everywhere would turn a forgotten key into a silently generated one on
+* `update` and `delete` as well.
+*/
+var BulkRecordSchema = object({
+	id: string().optional(),
+	data: record(string(), unknown())
+});
+/**
 * Column declaration for a structured (SQL-backed) collection.
 *
 * Logical types — the backend translates each to the matching SQLite
@@ -12947,6 +12960,10 @@ method(object({
 	collection: string(),
 	record: SettingsRecordSchema
 }), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	records: array(BulkRecordSchema).readonly()
+}), object({ inserted: number().int() }), { kind: "mutation" }), method(object({
 	namespace: string().optional(),
 	collection: string(),
 	id: string(),
@@ -13055,6 +13072,13 @@ method(_void(), EngineInfoSchema, { auth: "admin" }), method(object({
 }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	records: array(BulkRecordSchema).readonly()
+}), object({ inserted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	namespace: string().optional(),
 	collection: string(),
@@ -14875,6 +14899,82 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 	limit: number().optional(),
 	tags: record(string(), string()).optional()
 }), array(LogEntrySchema).readonly());
+var LoadContributionSchema = object({
+	role: _enum([
+		"decode",
+		"transcode",
+		"recording",
+		"streaming",
+		"detection"
+	]),
+	/**
+	* The NUMERIC device id — the same value every log line carries as
+	* `tags.deviceId`. `null` means this cost genuinely belongs to no single
+	* camera (a shared pool), NOT that the contributor forgot to look it up: a
+	* contributor that cannot name its camera must not emit the entry at all,
+	* because an unnamed per-camera entry is indistinguishable from a shared one
+	* and would quietly turn one camera's cost into everybody's.
+	*/
+	deviceId: number().int().positive().nullable(),
+	attribution: _enum([
+		"measured",
+		"accounted",
+		"unattributable"
+	]),
+	/**
+	* What ONE entry is, in the contributor's own words — `615/high`,
+	* `617/native`, `cuda:0 shared pool`. Free text because the unit differs per
+	* family and inventing a common one would lose the only information that
+	* makes two entries for the same camera distinguishable.
+	*/
+	unit: string(),
+	/**
+	* The OS process this cost lives in, when there is one. Present so a
+	* consumer can (a) tell two generations of the same unit apart across a
+	* restart, and (b) subtract claimed processes from the node's process
+	* snapshot to see what NOBODY claimed. Absent for an entry that owns no
+	* process of its own.
+	*/
+	pid: number().int().positive().optional(),
+	/**
+	* When this generation started. The pid's incarnation marker: a consumer
+	* differencing {@link LoadContributionSchema.shape.cpuSeconds} must drop the
+	* window when this changes, because the counter restarted from zero in a new
+	* process.
+	*/
+	startedAtMs: number().optional(),
+	/**
+	* CUMULATIVE CPU seconds this unit has consumed since it started — user +
+	* system, read from the child's own `/proc/<pid>/stat` at the moment the
+	* contribution is asked for.
+	*
+	* Cumulative and not a rate on purpose: a rate needs a window, a window
+	* needs a sampler, and a new per-node sampler is the defect half of
+	* `docs/architecture/load-ledger.md` documents. A counter can be differenced
+	* by whoever already keeps a history; a rate cannot be un-averaged.
+	*
+	* Absent — never zero — on a node with no `/proc`, on a read failure, and on
+	* an entry with no process.
+	*/
+	cpuSeconds: number().optional(),
+	/** Resident bytes of this unit's process, same source and same rules. */
+	rssBytes: number().optional()
+});
+var loadContributionCapability = {
+	name: "load-contribution",
+	scope: "system",
+	mode: "collection",
+	internal: true,
+	methods: { 
+	/**
+	* This addon's own cost entries, computed live from state it already
+	* holds. Inert: no persistence, no sampling, no timer. It is answered on
+	* whatever beat the caller already has.
+	*/
+list: method(_void(), array(LoadContributionSchema).readonly()) },
+	/** In-process only — enumerated through `addons.listCapabilityProviders`. */
+	mount: { kind: "skip" }
+};
 /**
 * `login-method` — collection cap through which auth addons contribute
 * their pre-auth login surfaces to the login page. This is the SINGLE,
@@ -15078,8 +15178,7 @@ var NodeProcessSchema = object({
 	classification: _enum([
 		"root",
 		"managed",
-		"system",
-		"ghost"
+		"system"
 	]),
 	/** `$process` addon binding when `managed`, else null. */
 	addonId: string().nullable(),
@@ -15087,22 +15186,39 @@ var NodeProcessSchema = object({
 	nodeId: string().nullable(),
 	/** Truncated command line. */
 	command: string(),
+	/**
+	* `ps pcpu` — CPU averaged over the process's WHOLE LIFETIME, not a rate.
+	* On a runner up for days it barely moves. Fine as a column, useless as a
+	* series: use `cpuMainPercent + cpuGcPercent` for anything time-varying.
+	*/
 	cpuPercent: number(),
 	memoryRssBytes: number(),
+	/**
+	* Instantaneous CPU% of the process's own threads over the last
+	* process-snapshot window, from a `/proc/<pid>/task/*` tick delta.
+	*
+	* `null` = UNKNOWN, never zero: no previous sample yet (first tick after
+	* boot), the pid was recycled, or this node is not Linux.
+	*/
+	cpuMainPercent: number().nullable(),
+	/**
+	* Instantaneous CPU% of V8's `V8Worker` platform pool over the same window.
+	*
+	* This is the number that rewrote the 2026-08-27 diagnosis — hub-main 73%,
+	* `stream-broker` 61% (`docs/architecture/load-ledger.md`). A CPU chart that
+	* does not separate it from `cpuMainPercent` shows "busy" where the truth is
+	* "allocating too much".
+	*
+	* Concurrent GC is the dominant tenant of that pool but not the only one
+	* (background compilation runs there too), so it is reported as
+	* "GC / V8 helpers" rather than as pure collection time. `null` has the same
+	* meaning as on `cpuMainPercent`.
+	*/
+	cpuGcPercent: number().nullable(),
+	/** Threads seen in the tick scan. `null` under the same conditions. */
+	threadCount: number().nullable(),
 	/** Wall-clock uptime (seconds). Parsed from `ps etime`. */
-	uptimeSec: number(),
-	/** True when ancestor walk reaches `ppid=1` (reparented to init/launchd). */
-	orphaned: boolean()
-});
-var KillProcessInputSchema = object({
-	pid: number(),
-	/** Force = SIGKILL. Default is SIGTERM. */
-	force: boolean().optional()
-});
-var KillProcessResultSchema = object({
-	success: boolean(),
-	reason: string().optional(),
-	signal: _enum(["SIGTERM", "SIGKILL"]).optional()
+	uptimeSec: number()
 });
 var DumpHeapSnapshotInputSchema = object({ 
 /** The addon whose runner should dump a heap snapshot. */
@@ -15115,6 +15231,104 @@ var DumpHeapSnapshotResultSchema = object({
 	pid: number().optional(),
 	reason: string().optional()
 });
+/**
+* One point of one function's series.
+*
+* The unsuffixed fields are the bucket's **MAXIMUM**, and that choice is the
+* point of the whole surface. The two obvious reductions both lie: a mean per
+* bucket smears a spike away, and taking every Nth sample skips it outright.
+* Either would give us a tool built to find peaks that does not show peaks.
+* `...Min` carries the other end, `samples` says how many raw snapshots folded
+* into the bucket, and a mean stays derivable where it is wanted.
+*
+* An UNREDUCED point is a one-sample bucket: `samples === 1` and each `...Min`
+* equals its unsuffixed twin. Reduced and unreduced are the same shape, so a
+* caller cannot tell which it received — which is what "one reader" means.
+*/
+var LoadPointSchema = object({
+	/** Bucket START, or the snapshot's own timestamp when unreduced. */
+	atMs: number(),
+	/** Raw snapshots in this bucket. Never 0 — AN EMPTY BUCKET IS ABSENT. */
+	samples: number().int(),
+	/**
+	* `null` = UNKNOWN and it PROPAGATES: a bucket is null unless every process
+	* of every snapshot in it reported a thread split. A partial sum is a
+	* smaller number that looks exactly as real as a complete one.
+	*/
+	cpuMainPercent: number().nullable(),
+	cpuMainPercentMin: number().nullable(),
+	cpuGcPercent: number().nullable(),
+	cpuGcPercentMin: number().nullable(),
+	/** Lifetime-average CPU%, summed. Always known — and never a rate. */
+	cpuLifetimePercent: number(),
+	cpuLifetimePercentMin: number(),
+	memoryRssBytes: number(),
+	memoryRssBytesMin: number(),
+	processCount: number().int(),
+	processCountMin: number().int()
+});
+/** One function's series. `key` is an addonId, `__root__` or `__unattributed__`. */
+var LoadFunctionSeriesSchema = object({
+	key: string(),
+	kind: _enum([
+		"addon",
+		"root",
+		"unattributed"
+	]),
+	/** Oldest-first. A missing interval is MISSING — never zero-filled. */
+	points: array(LoadPointSchema).readonly()
+});
+var NodeLoadSeriesSchema = object({
+	nodeId: string(),
+	/** One entry per function seen in the window, heaviest-first. */
+	series: array(LoadFunctionSeriesSchema).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.
+	*/
+	bucketMs: number(),
+	/** Raw snapshots that went into this answer, across both tiers. */
+	retainedSamples: number(),
+	/** Oldest snapshot represented, or `null` when nothing is retained. */
+	oldestAtMs: number().nullable(),
+	/** The fixed sampling cadence in force on the cluster, in ms. */
+	cadenceMs: number(),
+	/**
+	* Did the DURABLE tier contribute? `false` means the answer is the hot ring
+	* alone — an agent (which holds no table), or a store that refused.
+	* Reported because "the last hour" and "the last six hours" are different
+	* questions and an operator must not have to guess which was answered.
+	*/
+	durable: boolean()
+});
+var GetLoadSeriesInputSchema = object({
+	/**
+	* The node whose series is wanted.
+	*
+	* NOT named `nodeId`: the generated cap router strips a top-level
+	* `nodeId` from every method input and uses it to ROUTE the call to
+	* that node's provider (`generated-cap-routers.ts`). A series target
+	* called `nodeId` would silently become a routing pin and never reach
+	* the provider. The hub holds every node it hears from, so the
+	* ordinary call is unpinned — answered by the hub, for any node.
+	*/
+	forNodeId: string(),
+	/**
+	* EXCLUSIVE lower bound. A caller passes the newest `atMs` it already
+	* holds and receives only what it is missing, so seeding a live chart
+	* from this method cannot double a point already drawn.
+	*/
+	sinceMs: number().optional(),
+	/**
+	* Most points the caller wants PER FUNCTION. The window is reduced to fit,
+	* preserving min and max per bucket.
+	*
+	* Absent means NO reduction — legitimate for a short window and a trap for a
+	* long one, which is why a chart passes its own pixel width.
+	*/
+	maxPoints: number().int().positive().optional()
+});
 var SystemMetricsSchema = object({
 	cpuPercent: number(),
 	memoryPercent: number(),
@@ -15125,10 +15339,7 @@ var SystemMetricsSchema = object({
 	gpuPercent: number().optional(),
 	gpuMemoryPercent: number().optional()
 });
-method(_void(), SystemResourceSnapshotSchema), method(_void(), SystemResourceSnapshotSchema.nullable()), method(_void(), SystemMetricsSchema), method(object({ dirPath: string() }), DiskSpaceInfoSchema), method(_void(), MetricsGpuInfoSchema.nullable()), method(_void(), number().nullable()), method(object({ pids: array(number()) }), array(PidResourceStatsSchema)), method(_void(), array(AddonInstanceSchema).readonly()), method(object({ addonId: string() }), PidResourceStatsSchema.nullable()), method(_void(), array(NodeProcessSchema).readonly()), method(KillProcessInputSchema, KillProcessResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(DumpHeapSnapshotInputSchema, DumpHeapSnapshotResultSchema, {
+method(_void(), SystemResourceSnapshotSchema), method(_void(), SystemResourceSnapshotSchema.nullable()), method(_void(), SystemMetricsSchema), method(object({ dirPath: string() }), DiskSpaceInfoSchema), method(_void(), MetricsGpuInfoSchema.nullable()), method(_void(), number().nullable()), method(object({ pids: array(number()) }), array(PidResourceStatsSchema)), method(_void(), array(AddonInstanceSchema).readonly()), method(object({ addonId: string() }), PidResourceStatsSchema.nullable()), method(_void(), array(NodeProcessSchema).readonly()), method(GetLoadSeriesInputSchema, NodeLoadSeriesSchema), method(DumpHeapSnapshotInputSchema, DumpHeapSnapshotResultSchema, {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -29428,6 +29639,15 @@ var LoggingSettingsPatchSchema = object({
 * authority over the whole hierarchy and answers for every layer, so the
 * layer selector needs a name the transport does not already own.
 */
+/**
+* One contribution, plus WHO reported it.
+*
+* The addon and node are added by the hub as it enumerates providers, never by
+* the contributor: an addon reporting its own identity could report somebody
+* else's, and the whole point of this surface is that no claim is made by
+* anyone but its owner.
+*/
+var ReportedLoadContributionSchema = LoadContributionSchema.extend({ addonId: string() });
 var GetLoggingSettingsInputSchema = object({
 	scopeNodeId: string().optional(),
 	/**
@@ -29486,7 +29706,7 @@ method(_void(), FeatureManifestSchema), method(_void(), HealthStatusSchema), met
 }), method(_void(), SiteLocationStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), RequestCensusStatusSchema, { auth: "admin" }), method(GetLoggingSettingsInputSchema, LoggingSettingsStateSchema, { auth: "admin" }), method(SetLoggingSettingsInputSchema, LoggingSettingsStateSchema, {
+}), method(_void(), RequestCensusStatusSchema, { auth: "admin" }), method(_void(), array(ReportedLoadContributionSchema).readonly(), { auth: "admin" }), method(GetLoggingSettingsInputSchema, LoggingSettingsStateSchema, { auth: "admin" }), method(SetLoggingSettingsInputSchema, LoggingSettingsStateSchema, {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -31261,6 +31481,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"dataStoreProvider.insertMany": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dataStoreProvider.isEmpty": {
 		capName: "data-store-provider",
 		capScope: "system",
@@ -32575,6 +32801,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"loadContribution.list": {
+		capName: "load-contribution",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.downloadCa": {
 		capName: "local-network",
 		capScope: "system",
@@ -32875,17 +33107,17 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"metricsProvider.getProcessStats": {
+	"metricsProvider.getLoadSeries": {
 		capName: "metrics-provider",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"metricsProvider.killProcess": {
+	"metricsProvider.getProcessStats": {
 		capName: "metrics-provider",
 		capScope: "system",
 		addonId: null,
-		access: "create"
+		access: "view"
 	},
 	"metricsProvider.listAddonInstances": {
 		capName: "metrics-provider",
@@ -34897,6 +35129,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"settingsStore.insertMany": {
+		capName: "settings-store",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"settingsStore.isEmpty": {
 		capName: "settings-store",
 		capScope: "system",
@@ -35509,6 +35747,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"system.getLoadContributions": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"system.getLoggingSettings": {
 		capName: "system",
 		capScope: "system",
@@ -39934,6 +40178,12 @@ Object.defineProperty(exports, "literal", {
 		return literal;
 	}
 });
+Object.defineProperty(exports, "loadContributionCapability", {
+	enumerable: true,
+	get: function() {
+		return loadContributionCapability;
+	}
+});
 Object.defineProperty(exports, "logChannelsCapability", {
 	enumerable: true,
 	get: function() {