@camstack/system 1.2.222 → 1.2.224

package/dist/{manifest-system-deps-YYKKCKSF.js → manifest-system-deps-8x1jgPz_.js}

@@ -1470,6 +1470,134 @@ function formatGcCensus(window) {
 	const perMin = (n) => window.windowMs <= 0 ? "?" : (n / (window.windowMs / 6e4)).toFixed(1);
 	return ` gc=maj${window.majors}/min${window.minors}/inc${window.incrementals}@${Math.round(window.windowMs / 1e3)}s gcMajPerMin=${perMin(window.majors)} gcPauseMs=${Math.round(window.pauseMs)}`;
 }
+/**
+* The census. Always exists — `process.cpuUsage()` is available on every
+* platform Node runs on, so unlike the GC census there is no runtime in which
+* this has nothing to report.
+*/
+function createProcessCpuCensus(options) {
+	let windowStart = options.startedAt;
+	let cpuAtStart = options.cpuUsageUs();
+	let tasksAtStart = options.readTasks();
+	return { read: (at) => {
+		const windowMs = at - windowStart;
+		if (windowMs < 1e3) return null;
+		const cpuNow = options.cpuUsageUs();
+		const tasksNow = options.readTasks();
+		const cpuUs = cpuNow - cpuAtStart;
+		const percentOfCore = cpuUs <= 0 ? 0 : round1(cpuUs / 1e3 / windowMs * 100);
+		const reading = {
+			percentOfCore,
+			windowMs,
+			v8Workers: shareOfWorkers(tasksAtStart, tasksNow, percentOfCore)
+		};
+		windowStart = at;
+		cpuAtStart = cpuNow;
+		tasksAtStart = tasksNow;
+		return reading;
+	} };
+}
+/**
+* The worker share, or `null`.
+*
+* Every way this can fail to be a reading returns `null`: either snapshot
+* missing, no thread scheduled at all across the window (a share of nothing is
+* not zero percent — it is no measurement), or a delta that went BACKWARDS,
+* which means the thread set changed under us and the subtraction describes
+* nothing real.
+*/
+function shareOfWorkers(before, after, percentOfCore) {
+	if (before === null || after === null) return null;
+	const b = sum(before);
+	const a = sum(after);
+	const workerTicks = a.worker - b.worker;
+	const totalTicks = a.total - b.total;
+	if (workerTicks < 0 || totalTicks <= 0 || workerTicks > totalTicks) return null;
+	return {
+		percentOfCore: round1(percentOfCore * (workerTicks / totalTicks)),
+		threads: a.workerThreads
+	};
+}
+var V8_WORKER_COMM = "V8Worker";
+function sum(tasks) {
+	let worker = 0;
+	let total = 0;
+	let workerThreads = 0;
+	for (const t of tasks) {
+		total += t.ticks;
+		if (t.comm === V8_WORKER_COMM) {
+			worker += t.ticks;
+			workerThreads += 1;
+		}
+	}
+	return {
+		worker,
+		total,
+		workerThreads
+	};
+}
+function round1(n) {
+	return Math.round(n * 10) / 10;
+}
+/**
+* Per-thread ticks for THIS process, or `null` where that cannot be read.
+*
+* `/proc/self/task/<tid>/stat` is `pid (comm) state ppid …`, and `comm` may
+* itself contain spaces and parentheses — so the split is on the LAST `)`,
+* never on whitespace. `utime` and `stime` are the 12th and 13th fields after
+* it. Everything that can fail is inside the try: a non-Linux platform, a
+* container with `hidepid`, a thread that exits between the readdir and the
+* read. A thread that vanishes mid-scan is skipped rather than failing the
+* whole reading — it contributed to neither snapshot's total.
+*/
+function readSelfTaskTicks() {
+	try {
+		const tids = (0, node_fs.readdirSync)("/proc/self/task");
+		const out = [];
+		for (const tid of tids) {
+			const parsed = parseTaskStat(tid);
+			if (parsed !== null) out.push(parsed);
+		}
+		return out.length === 0 ? null : out;
+	} catch {
+		return null;
+	}
+}
+function parseTaskStat(tid) {
+	try {
+		const raw = (0, node_fs.readFileSync)(`/proc/self/task/${tid}/stat`, "utf8");
+		const close = raw.lastIndexOf(") ");
+		const open = raw.indexOf(" (");
+		if (close < 0 || open < 0 || close <= open) return null;
+		const comm = raw.slice(open + 2, close);
+		const fields = raw.slice(close + 2).split(" ");
+		const utime = Number(fields[11]);
+		const stime = Number(fields[12]);
+		if (!Number.isFinite(utime) || !Number.isFinite(stime)) return null;
+		return {
+			comm,
+			ticks: utime + stime
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* The two fields, APPENDED LAST on the `[mem]` line — after everything D446,
+* D456 and D458 appended, so every Loki prefix written since 2026-08-29 still
+* matches (D446's rule).
+*
+* `procCpu` prints whenever there is a window, including at 0.0 %, because an
+* idle process is a reading and it is the one that says a runner is alive and
+* doing nothing. `v8WorkerCpu` is CONDITIONAL and its absence is the reading:
+* the platform could not be asked. It carries its thread count because "36.6 %
+* over four threads" and "36.6 % on one" are different faults.
+*/
+function formatProcessCpu(reading) {
+	if (reading === null || reading === void 0) return "";
+	const workers = reading.v8Workers;
+	return ` procCpu=${reading.percentOfCore.toFixed(1)}%` + (workers === null ? "" : ` v8WorkerCpu=${workers.percentOfCore.toFixed(1)}%/${workers.threads}thr`);
+}
 //#endregion
 //#region src/kernel/heap-watch.ts
 /**
@@ -2069,6 +2197,15 @@ function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, i
 	const now = reclaimOptions?.now ?? (() => Date.now());
 	const gcObserver = probes?.gcObserver ?? nodeGcObserver();
 	const gcCensus = createGcCensus(gcObserver.install, gcObserver.kinds, now());
+	const cpuProbe = probes?.processCpu;
+	const processCpu = createProcessCpuCensus({
+		cpuUsageUs: cpuProbe?.cpuUsageUs ?? (() => {
+			const u = process.cpuUsage();
+			return u.user + u.system;
+		}),
+		readTasks: cpuProbe?.readTasks ?? readSelfTaskTicks,
+		startedAt: now()
+	});
 	const triggerMb = reclaimOptions?.triggerMb ?? 1024;
 	const minIntervalMs = reclaimOptions?.minIntervalMs ?? 12e4;
 	const steadyStateIntervalMs = reclaimOptions?.steadyStateIntervalMs ?? 6e5;
@@ -2171,7 +2308,7 @@ function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, i
 			const due = at - lastLoggedAt >= intervalMs;
 			if (mode === "escalated" || due) {
 				lastLoggedAt = at;
-				const line = format(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}` + formatSocketPlane(socketPlane?.read()) + formatMeshQueue(meshQueue?.()) + formatGcCensus(gcCensus?.read(at)));
+				const line = format(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}` + formatSocketPlane(socketPlane?.read()) + formatMeshQueue(meshQueue?.()) + formatGcCensus(gcCensus?.read(at)) + formatProcessCpu(processCpu.read(at)));
 				if (sample.nearLimit) sink.warn(`${line} — APPROACHING HEAP LIMIT`);
 				else if (mode === "escalated") sink.warn(`${line} — heap elevated, sampling every ${probeIntervalMs}ms`);
 				else sink.info(line);

package/dist/{manifest-system-deps-D4cmEnqQ.mjs → manifest-system-deps-BhYmLVHw.mjs}

@@ -6,7 +6,7 @@ import { unlink } from "node:fs/promises";
 import * as path$1 from "node:path";
 import { isAbsolute, join } from "node:path";
 import * as fs from "node:fs";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { execFile } from "node:child_process";
 import * as os from "node:os";
 import { tmpdir } from "node:os";
@@ -1467,6 +1467,134 @@ function formatGcCensus(window) {
 	const perMin = (n) => window.windowMs <= 0 ? "?" : (n / (window.windowMs / 6e4)).toFixed(1);
 	return ` gc=maj${window.majors}/min${window.minors}/inc${window.incrementals}@${Math.round(window.windowMs / 1e3)}s gcMajPerMin=${perMin(window.majors)} gcPauseMs=${Math.round(window.pauseMs)}`;
 }
+/**
+* The census. Always exists — `process.cpuUsage()` is available on every
+* platform Node runs on, so unlike the GC census there is no runtime in which
+* this has nothing to report.
+*/
+function createProcessCpuCensus(options) {
+	let windowStart = options.startedAt;
+	let cpuAtStart = options.cpuUsageUs();
+	let tasksAtStart = options.readTasks();
+	return { read: (at) => {
+		const windowMs = at - windowStart;
+		if (windowMs < 1e3) return null;
+		const cpuNow = options.cpuUsageUs();
+		const tasksNow = options.readTasks();
+		const cpuUs = cpuNow - cpuAtStart;
+		const percentOfCore = cpuUs <= 0 ? 0 : round1(cpuUs / 1e3 / windowMs * 100);
+		const reading = {
+			percentOfCore,
+			windowMs,
+			v8Workers: shareOfWorkers(tasksAtStart, tasksNow, percentOfCore)
+		};
+		windowStart = at;
+		cpuAtStart = cpuNow;
+		tasksAtStart = tasksNow;
+		return reading;
+	} };
+}
+/**
+* The worker share, or `null`.
+*
+* Every way this can fail to be a reading returns `null`: either snapshot
+* missing, no thread scheduled at all across the window (a share of nothing is
+* not zero percent — it is no measurement), or a delta that went BACKWARDS,
+* which means the thread set changed under us and the subtraction describes
+* nothing real.
+*/
+function shareOfWorkers(before, after, percentOfCore) {
+	if (before === null || after === null) return null;
+	const b = sum(before);
+	const a = sum(after);
+	const workerTicks = a.worker - b.worker;
+	const totalTicks = a.total - b.total;
+	if (workerTicks < 0 || totalTicks <= 0 || workerTicks > totalTicks) return null;
+	return {
+		percentOfCore: round1(percentOfCore * (workerTicks / totalTicks)),
+		threads: a.workerThreads
+	};
+}
+var V8_WORKER_COMM = "V8Worker";
+function sum(tasks) {
+	let worker = 0;
+	let total = 0;
+	let workerThreads = 0;
+	for (const t of tasks) {
+		total += t.ticks;
+		if (t.comm === V8_WORKER_COMM) {
+			worker += t.ticks;
+			workerThreads += 1;
+		}
+	}
+	return {
+		worker,
+		total,
+		workerThreads
+	};
+}
+function round1(n) {
+	return Math.round(n * 10) / 10;
+}
+/**
+* Per-thread ticks for THIS process, or `null` where that cannot be read.
+*
+* `/proc/self/task/<tid>/stat` is `pid (comm) state ppid …`, and `comm` may
+* itself contain spaces and parentheses — so the split is on the LAST `)`,
+* never on whitespace. `utime` and `stime` are the 12th and 13th fields after
+* it. Everything that can fail is inside the try: a non-Linux platform, a
+* container with `hidepid`, a thread that exits between the readdir and the
+* read. A thread that vanishes mid-scan is skipped rather than failing the
+* whole reading — it contributed to neither snapshot's total.
+*/
+function readSelfTaskTicks() {
+	try {
+		const tids = readdirSync("/proc/self/task");
+		const out = [];
+		for (const tid of tids) {
+			const parsed = parseTaskStat(tid);
+			if (parsed !== null) out.push(parsed);
+		}
+		return out.length === 0 ? null : out;
+	} catch {
+		return null;
+	}
+}
+function parseTaskStat(tid) {
+	try {
+		const raw = readFileSync(`/proc/self/task/${tid}/stat`, "utf8");
+		const close = raw.lastIndexOf(") ");
+		const open = raw.indexOf(" (");
+		if (close < 0 || open < 0 || close <= open) return null;
+		const comm = raw.slice(open + 2, close);
+		const fields = raw.slice(close + 2).split(" ");
+		const utime = Number(fields[11]);
+		const stime = Number(fields[12]);
+		if (!Number.isFinite(utime) || !Number.isFinite(stime)) return null;
+		return {
+			comm,
+			ticks: utime + stime
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* The two fields, APPENDED LAST on the `[mem]` line — after everything D446,
+* D456 and D458 appended, so every Loki prefix written since 2026-08-29 still
+* matches (D446's rule).
+*
+* `procCpu` prints whenever there is a window, including at 0.0 %, because an
+* idle process is a reading and it is the one that says a runner is alive and
+* doing nothing. `v8WorkerCpu` is CONDITIONAL and its absence is the reading:
+* the platform could not be asked. It carries its thread count because "36.6 %
+* over four threads" and "36.6 % on one" are different faults.
+*/
+function formatProcessCpu(reading) {
+	if (reading === null || reading === void 0) return "";
+	const workers = reading.v8Workers;
+	return ` procCpu=${reading.percentOfCore.toFixed(1)}%` + (workers === null ? "" : ` v8WorkerCpu=${workers.percentOfCore.toFixed(1)}%/${workers.threads}thr`);
+}
 //#endregion
 //#region src/kernel/heap-watch.ts
 /**
@@ -2066,6 +2194,15 @@ function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, i
 	const now = reclaimOptions?.now ?? (() => Date.now());
 	const gcObserver = probes?.gcObserver ?? nodeGcObserver();
 	const gcCensus = createGcCensus(gcObserver.install, gcObserver.kinds, now());
+	const cpuProbe = probes?.processCpu;
+	const processCpu = createProcessCpuCensus({
+		cpuUsageUs: cpuProbe?.cpuUsageUs ?? (() => {
+			const u = process.cpuUsage();
+			return u.user + u.system;
+		}),
+		readTasks: cpuProbe?.readTasks ?? readSelfTaskTicks,
+		startedAt: now()
+	});
 	const triggerMb = reclaimOptions?.triggerMb ?? 1024;
 	const minIntervalMs = reclaimOptions?.minIntervalMs ?? 12e4;
 	const steadyStateIntervalMs = reclaimOptions?.steadyStateIntervalMs ?? 6e5;
@@ -2168,7 +2305,7 @@ function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, i
 			const due = at - lastLoggedAt >= intervalMs;
 			if (mode === "escalated" || due) {
 				lastLoggedAt = at;
-				const line = format(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}` + formatSocketPlane(socketPlane?.read()) + formatMeshQueue(meshQueue?.()) + formatGcCensus(gcCensus?.read(at)));
+				const line = format(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}` + formatSocketPlane(socketPlane?.read()) + formatMeshQueue(meshQueue?.()) + formatGcCensus(gcCensus?.read(at)) + formatProcessCpu(processCpu.read(at)));
 				if (sample.nearLimit) sink.warn(`${line} — APPROACHING HEAP LIMIT`);
 				else if (mode === "escalated") sink.warn(`${line} — heap elevated, sampling every ${probeIntervalMs}ms`);
 				else sink.info(line);

package/dist/{retired-settings-keys-DmVZAH9M.mjs → retired-settings-keys-B0JHsynV.mjs}

@@ -1,4 +1,4 @@
-import { an as asJsonObject } from "./dist-T9GvfhgV.mjs";
+import { an as asJsonObject } from "./dist-DmfYrdAn.mjs";
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/dist/{retired-settings-keys-Dh-XMfFx.js → retired-settings-keys-C-jOWHI0.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-0sWJNwme.js");
+const require_dist = require("./dist-DdRxWA7g.js");
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.222",
+  "version": "1.2.224",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",