@camstack/system 1.2.470 → 1.2.472

package/dist/builtins/liveness-monitor/liveness-monitor.addon.mjs

@@ -1,4 +1,7 @@
-import { $r as errMsg, Da as EventCategory, Ui as createEvent, ei as BaseAddon, it as RecordingStatusSchema, nt as RECORDING_SOURCE_CAMSTACK_ADDON } from "../../dist-X1r44BdF.mjs";
+import { $r as errMsg, Da as EventCategory, Ui as createEvent, Vn as mayWriteToLocation, ei as BaseAddon, it as RecordingStatusSchema, nt as RECORDING_SOURCE_CAMSTACK_ADDON } from "../../dist-CdFkkmXW.mjs";
+import * as fsp from "node:fs/promises";
+import path from "node:path";
+import { constants } from "node:fs";
 //#region src/builtins/liveness-monitor/liveness-checks.ts
 var NO_DEVICES = "liveness:no-devices";
 var ALL_OFFLINE = "liveness:all-devices-offline";
@@ -50,6 +53,198 @@ function isLivenessFindingId(id) {
 	return id === NO_DEVICES || id === ALL_OFFLINE || id.startsWith(NO_FOOTAGE_PREFIX);
 }
 //#endregion
+//#region src/builtins/liveness-monitor/liveness-reporter.ts
+/**
+* Announce new liveness faults and their recoveries — never an unchanged fault.
+*
+* One ERROR line and one `SystemLivenessFailed` event per NEW finding id (the
+* alert centre turns it into one persistent alert), one INFO line and one
+* `SystemLivenessRecovered` when it is gone. Several families of checks run on
+* different cadences (the device checks wait out the boot grace, the storage
+* check does not), so a recovery is judged only within the family that was
+* just evaluated: a storage check that found nothing must not "recover" a
+* device finding it never looked at.
+*/
+/** Event source stamped on every emission — the addon that observed it. */
+var LIVENESS_SOURCE = {
+	type: "addon",
+	id: "liveness-monitor"
+};
+var LivenessReporter = class {
+	deps;
+	/** Finding ids currently reported, so recovery can be detected and announced. */
+	active = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/**
+	* @param findings what the family found this evaluation
+	* @param inFamily which ids the family owns — only those can recover here
+	*/
+	report(findings, inFamily) {
+		const current = new Set(findings.map((f) => f.id));
+		for (const finding of findings) {
+			if (this.active.has(finding.id)) continue;
+			this.active.add(finding.id);
+			this.deps.logger.error(`liveness: ${finding.title} — ${finding.message}`, {
+				...finding.deviceId !== void 0 ? { tags: { deviceId: finding.deviceId } } : {},
+				meta: {
+					findingId: finding.id,
+					severity: finding.severity
+				}
+			});
+			this.deps.emit(createEvent(EventCategory.SystemLivenessFailed, LIVENESS_SOURCE, {
+				findingId: finding.id,
+				severity: finding.severity,
+				title: finding.title,
+				message: finding.message,
+				...finding.deviceId !== void 0 ? { deviceId: finding.deviceId } : {},
+				...finding.deviceName !== void 0 ? { name: finding.deviceName } : {}
+			}));
+		}
+		for (const id of [...this.active]) {
+			if (current.has(id) || !inFamily(id)) continue;
+			this.active.delete(id);
+			this.deps.logger.info(`liveness: recovered — ${id}`, { meta: { findingId: id } });
+			this.deps.emit(createEvent(EventCategory.SystemLivenessRecovered, LIVENESS_SOURCE, { findingId: id }));
+		}
+	}
+};
+//#endregion
+//#region src/builtins/liveness-monitor/storage-root-access.ts
+/**
+* Can this node WRITE where its storage locations say media goes?
+*
+* 2026-10-23, a fresh install of the dev hub: the bind mounted at
+* `/recordings` was `root:root 0755` while the hub runs as uid 1001. Nothing
+* said so at boot; the first sign was an `EACCES` on `/recordings/artifacts`,
+* and recordings would have failed one write at a time. A root the process
+* cannot write is a fact known the moment the node starts, so it is reported
+* then — once, naming the path, its owner, its mode and the uid — instead of
+* as a stream of per-write errors.
+*
+* Only a location this node may WRITE (`mayWriteToLocation`), served by the
+* local filesystem provider, on this node, with an absolute `basePath`, is
+* judged. A root that does not exist yet is judged by its nearest existing
+* ancestor: that is the directory the node would have to create it in.
+*
+* A probe that cannot answer (a stat that fails for a reason other than
+* permission) is `unknown` and never a finding (D393): an unreadable fact is
+* not an unwritable disk.
+*/
+/** The local filesystem storage provider's id (`FilesystemStorageProvider.providerId`). */
+var FILESYSTEM_PROVIDER_ID = "filesystem-storage";
+var UNWRITABLE_PREFIX = "liveness:storage-root-unwritable:";
+/** The hub-local, writable filesystem roots among `locations`, deduplicated by path. */
+function storageRootTargets(locations, localNodeId) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const location of locations) {
+		if (location.providerId !== FILESYSTEM_PROVIDER_ID) continue;
+		if (location.nodeId !== void 0 && location.nodeId !== localNodeId) continue;
+		if (!mayWriteToLocation(location)) continue;
+		const basePath = location.config["basePath"];
+		if (typeof basePath !== "string" || !path.isAbsolute(basePath)) continue;
+		const root = path.resolve(basePath);
+		byPath.set(root, [...byPath.get(root) ?? [], location.id]);
+	}
+	return [...byPath.entries()].map(([root, locationIds]) => ({
+		path: root,
+		locationIds: locationIds.toSorted()
+	})).toSorted((a, b) => a.path.localeCompare(b.path));
+}
+function isMissing(err) {
+	return err instanceof Error && "code" in err && (err.code === "ENOENT" || err.code === "ENOTDIR");
+}
+/** Probe one root: the root itself, or the nearest ancestor that exists. */
+async function probeStorageRoot(target, probe) {
+	let dir = target.path;
+	let stat;
+	for (;;) try {
+		stat = await probe.stat(dir);
+		break;
+	} catch (err) {
+		const parent = path.dirname(dir);
+		if (!isMissing(err) || parent === dir) return {
+			kind: "unknown",
+			target,
+			reason: `stat ${dir} failed: ${errMsg(err)}`
+		};
+		dir = parent;
+	}
+	try {
+		await probe.canWrite(dir);
+		return {
+			kind: "writable",
+			target
+		};
+	} catch (err) {
+		return {
+			kind: "unwritable",
+			target,
+			blockedAt: dir,
+			stat,
+			reason: errMsg(err)
+		};
+	}
+}
+function octalMode(mode) {
+	return (mode & 4095).toString(8).padStart(4, "0");
+}
+function processIdentity(probe) {
+	if (probe.processUid === null) return "this process";
+	return `uid ${String(probe.processUid)}` + (probe.processGid === null ? "" : ` (gid ${String(probe.processGid)})`);
+}
+/**
+* One finding per DIRECTORY that refused — several roots under one unwritable
+* mount (`/recordings` holding recordings, event media and artifacts) are one
+* cause and one alert. Stable id = that directory.
+*/
+function storageRootFindings(results, probe) {
+	const byBlocked = /* @__PURE__ */ new Map();
+	for (const result of results) {
+		if (result.kind !== "unwritable") continue;
+		const entry = byBlocked.get(result.blockedAt) ?? {
+			stat: result.stat,
+			roots: [],
+			locationIds: []
+		};
+		entry.roots.push(result.target.path);
+		entry.locationIds.push(...result.target.locationIds);
+		byBlocked.set(result.blockedAt, entry);
+	}
+	const uidFix = probe.processUid === null ? "<uid>" : String(probe.processUid);
+	const gidFix = probe.processGid === null ? "<gid>" : String(probe.processGid);
+	return [...byBlocked.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([blockedAt, { stat, roots, locationIds }]) => {
+		const missing = roots.filter((r) => r !== blockedAt);
+		const below = missing.length > 0 ? ` (${missing.join(", ")} must be created inside it)` : "";
+		return {
+			id: `${UNWRITABLE_PREFIX}${blockedAt}`,
+			severity: "error",
+			title: "Storage location not writable",
+			message: `${blockedAt} is owned by ${String(stat.uid)}:${String(stat.gid)} with mode ${octalMode(stat.mode)}, and CamStack runs as ${processIdentity(probe)} — nothing can be written there${below}. Locations affected: ${locationIds.toSorted().join(", ")}. Fix the ownership on the host, e.g. chown -R ${uidFix}:${gidFix} <the host directory bound at ${blockedAt}>.`
+		};
+	});
+}
+function isStorageRootFindingId(id) {
+	return id.startsWith(UNWRITABLE_PREFIX);
+}
+/** The real probe: `fs.access(W_OK | X_OK)` as THIS process, and `fs.stat`. */
+function nodeStorageRootProbe(fs) {
+	return {
+		canWrite: (dir) => fs.access(dir, constants.W_OK | constants.X_OK),
+		stat: async (dir) => {
+			const st = await fs.stat(dir);
+			return {
+				uid: st.uid,
+				gid: st.gid,
+				mode: st.mode
+			};
+		},
+		processUid: typeof process.getuid === "function" ? process.getuid() : null,
+		processGid: typeof process.getgid === "function" ? process.getgid() : null
+	};
+}
+//#endregion
 //#region src/builtins/liveness-monitor/liveness-monitor.addon.ts
 /**
 * liveness-monitor — the node states, out loud, when it has stopped working.
@@ -72,11 +267,8 @@ function isLivenessFindingId(id) {
 * cause the outage it was meant to report — this repo has already stopped a
 * hub that way once (the remedial-action watcher, 2026-07-30).
 */
-/** Event source stamped on every emission — the addon that observed it. */
-var LIVENESS_SOURCE = {
-	type: "addon",
-	id: "liveness-monitor"
-};
+/** The node this monitor runs on (it is hub-only). */
+var HUB_NODE_ID = "hub";
 /** How often the invariants are checked. */
 var TICK_INTERVAL_MS = 5 * 6e4;
 /**
@@ -99,13 +291,19 @@ var RECORDING_LOOKBACK_MS = 1440 * 6e4;
 var LivenessMonitorAddon = class extends BaseAddon {
 	tickTimer = null;
 	startedAtMs = 0;
-	/** Finding ids currently reported, so recovery can be detected and announced. */
-	active = /* @__PURE__ */ new Set();
+	reporter = null;
+	/** Roots whose writability could not be read, already said once. */
+	unknownRootsSaid = /* @__PURE__ */ new Set();
 	constructor() {
 		super({});
 	}
 	async onInitialize() {
 		this.startedAtMs = Date.now();
+		this.reporter = new LivenessReporter({
+			logger: this.ctx.logger,
+			emit: (event) => this.ctx.eventBus.emit(event)
+		});
+		this.checkStorageRoots();
 		this.tickTimer = setInterval(() => {
 			this.tick();
 		}, TICK_INTERVAL_MS);
@@ -125,11 +323,12 @@ var LivenessMonitorAddon = class extends BaseAddon {
 	* without waiting out the interval.
 	*/
 	async tick() {
-		if (Date.now() - this.startedAtMs < BOOT_GRACE_MS) return [];
+		const storage = await this.checkStorageRoots();
+		if (Date.now() - this.startedAtMs < BOOT_GRACE_MS) return storage;
 		try {
 			const findings = evaluateLiveness(await this.gather());
-			this.report(findings);
-			return findings;
+			this.reporter?.report(findings, isLivenessFindingId);
+			return [...storage, ...findings];
 		} catch (err) {
 			this.ctx.logger.error("liveness-monitor: check failed — node health is UNKNOWN this tick", { meta: { error: errMsg(err) } });
 			return [];
@@ -204,33 +403,33 @@ var LivenessMonitorAddon = class extends BaseAddon {
 		this.ctx.logger.warn(`liveness: recording availability was unreadable (${window}) — this camera is not judged this tick`, { tags: { deviceId } });
 		return null;
 	}
-	/** Announce new faults and recoveries; say nothing about an unchanged fault. */
-	report(findings) {
-		const current = new Set(findings.map((f) => f.id));
-		for (const finding of findings) {
-			if (this.active.has(finding.id)) continue;
-			this.active.add(finding.id);
-			this.ctx.logger.error(`liveness: ${finding.title} — ${finding.message}`, {
-				...finding.deviceId !== void 0 ? { tags: { deviceId: finding.deviceId } } : {},
-				meta: {
-					findingId: finding.id,
-					severity: finding.severity
-				}
-			});
-			this.ctx.eventBus.emit(createEvent(EventCategory.SystemLivenessFailed, LIVENESS_SOURCE, {
-				findingId: finding.id,
-				severity: finding.severity,
-				title: finding.title,
-				message: finding.message,
-				...finding.deviceId !== void 0 ? { deviceId: finding.deviceId } : {},
-				...finding.deviceName !== void 0 ? { name: finding.deviceName } : {}
-			}));
-		}
-		for (const id of [...this.active]) {
-			if (current.has(id)) continue;
-			this.active.delete(id);
-			this.ctx.logger.info(`liveness: recovered — ${id}`, { meta: { findingId: id } });
-			this.ctx.eventBus.emit(createEvent(EventCategory.SystemLivenessRecovered, LIVENESS_SOURCE, { findingId: id }));
+	/**
+	* Every storage root this node writes to must be writable BY THIS PROCESS.
+	* Reported through the same finding path (one ERROR, one alert, a recovery
+	* when it is fixed). Never throws: an unreadable list is said and skipped.
+	*/
+	async checkStorageRoots() {
+		const reporter = this.reporter;
+		if (reporter === null) return [];
+		try {
+			const locations = await this.ctx.api.storage.listLocations.query({});
+			const probe = nodeStorageRootProbe(fsp);
+			const results = await Promise.all(storageRootTargets(locations, HUB_NODE_ID).map((t) => probeStorageRoot(t, probe)));
+			for (const result of results) {
+				if (result.kind !== "unknown" || this.unknownRootsSaid.has(result.target.path)) continue;
+				this.unknownRootsSaid.add(result.target.path);
+				this.ctx.logger.warn("liveness: storage root writability could not be read — not judged", { meta: {
+					path: result.target.path,
+					locationIds: result.target.locationIds,
+					reason: result.reason
+				} });
+			}
+			const findings = storageRootFindings(results, probe);
+			reporter.report(findings, isStorageRootFindingId);
+			return findings;
+		} catch (err) {
+			this.ctx.logger.warn("liveness: storage locations unreadable — storage roots not checked", { meta: { error: errMsg(err) } });
+			return [];
 		}
 	}
 };

package/dist/builtins/liveness-monitor/liveness-reporter.d.ts

@@ -0,0 +1,28 @@
+/**
+* Announce new liveness faults and their recoveries — never an unchanged fault.
+*
+* One ERROR line and one `SystemLivenessFailed` event per NEW finding id (the
+* alert centre turns it into one persistent alert), one INFO line and one
+* `SystemLivenessRecovered` when it is gone. Several families of checks run on
+* different cadences (the device checks wait out the boot grace, the storage
+* check does not), so a recovery is judged only within the family that was
+* just evaluated: a storage check that found nothing must not "recover" a
+* device finding it never looked at.
+*/
+import { type IScopedLogger, type SystemEvent } from "@camstack/types";
+import type { LivenessFinding } from "./liveness-checks.js";
+export interface LivenessReporterDeps {
+	readonly logger: IScopedLogger;
+	readonly emit: (event: SystemEvent) => void;
+}
+export declare class LivenessReporter {
+	private readonly deps;
+	/** Finding ids currently reported, so recovery can be detected and announced. */
+	private readonly active;
+	constructor(deps: LivenessReporterDeps);
+	/**
+	* @param findings what the family found this evaluation
+	* @param inFamily which ids the family owns — only those can recover here
+	*/
+	report(findings: readonly LivenessFinding[], inFamily: (id: string) => boolean): void;
+}

package/dist/builtins/liveness-monitor/storage-root-access.d.ts

@@ -0,0 +1,53 @@
+import { type StorageLocation } from "@camstack/types";
+import type { LivenessFinding } from "./liveness-checks.js";
+/** Owner and permission bits of a directory, as `stat` reports them. */
+export interface DirStat {
+	readonly uid: number;
+	readonly gid: number;
+	readonly mode: number;
+}
+/** The two filesystem reads the check makes; injected so a test can run without root. */
+export interface StorageRootProbe {
+	/** Resolves when the CURRENT process may write (and traverse) `dir`; rejects otherwise. */
+	readonly canWrite: (dir: string) => Promise<void>;
+	readonly stat: (dir: string) => Promise<DirStat>;
+	/** The process uid/gid, or `null` where the platform has none (Windows). */
+	readonly processUid: number | null;
+	readonly processGid: number | null;
+}
+/** One root this node must be able to write, and every location that writes under it. */
+export interface StorageRootTarget {
+	readonly path: string;
+	readonly locationIds: readonly string[];
+}
+export type StorageRootAccess = {
+	readonly kind: "writable";
+	readonly target: StorageRootTarget;
+} | {
+	readonly kind: "unwritable";
+	readonly target: StorageRootTarget;
+	/** The directory that refused: the root itself, or its nearest existing ancestor. */
+	readonly blockedAt: string;
+	readonly stat: DirStat;
+	readonly reason: string;
+} | {
+	readonly kind: "unknown";
+	readonly target: StorageRootTarget;
+	readonly reason: string;
+};
+/** The hub-local, writable filesystem roots among `locations`, deduplicated by path. */
+export declare function storageRootTargets(locations: readonly StorageLocation[], localNodeId: string): readonly StorageRootTarget[];
+/** Probe one root: the root itself, or the nearest ancestor that exists. */
+export declare function probeStorageRoot(target: StorageRootTarget, probe: StorageRootProbe): Promise<StorageRootAccess>;
+/**
+* One finding per DIRECTORY that refused — several roots under one unwritable
+* mount (`/recordings` holding recordings, event media and artifacts) are one
+* cause and one alert. Stable id = that directory.
+*/
+export declare function storageRootFindings(results: readonly StorageRootAccess[], probe: StorageRootProbe): readonly LivenessFinding[];
+export declare function isStorageRootFindingId(id: string): boolean;
+/** The real probe: `fs.access(W_OK | X_OK)` as THIS process, and `fs.stat`. */
+export declare function nodeStorageRootProbe(fs: {
+	readonly access: (p: string, mode: number) => Promise<void>;
+	readonly stat: (p: string) => Promise<DirStat>;
+}): StorageRootProbe;

package/dist/builtins/local-auth/local-auth.addon.js

@@ -3,10 +3,10 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DRL3rEfN.js");
+const require_dist = require("../../dist-DX5Fu3mV.js");
 const require_safe_buffer$1 = require("../../safe-buffer-D3aoa-7X.js");
 const require_ms$1 = require("../../ms-LB3giGoU.js");
-const require_device_ca = require("../../device-ca-R4MZZtc0.js");
+const require_device_ca = require("../../device-ca-CfiIg3a9.js");
 const require_read_all_rows$1 = require("../../read-all-rows-CVoO1ONM.js");
 let zod = require("zod");
 let node_crypto = require("node:crypto");

package/dist/builtins/local-auth/local-auth.addon.mjs

@@ -1,15 +1,15 @@
 import { i as __require, o as __toESM, t as __commonJSMin } from "../../chunk-CNf5ZN-e.mjs";
-import { $ as PreferenceDeviceIdSchema, At as buildDeviceSignatureMessage, E as DEVICE_ENROLLMENT_TTL_MS, Ki as defineRecordKinds, O as DEVICE_NONCE_TTL_MS, Q as PREFERENCES_MAX_VALUE_BYTES, Qt as deviceCredentialsCapability, Ta as userError, ei as BaseAddon, et as PreferenceNamespaceSchema, gt as UserRecordSchema, h as CREDENTIAL_TOKEN_AUDIENCE, hn as formatDeviceRevoker, jr as userManagementCapability, kt as buildDeviceEnrollmentLink, lt as SsoBridgeClaimsSchema, mt as TokenScopeSchema, oa as makeSecretMarker, ra as isSecretMarker, st as ScopedTokenSchema, tt as PreferenceValueSchema, wn as isCredentialTokenPayload, wt as authProviderCapability, y as CredentialTokenClaimsSchema } from "../../dist-X1r44BdF.mjs";
+import { $ as PreferenceDeviceIdSchema, At as buildDeviceSignatureMessage, E as DEVICE_ENROLLMENT_TTL_MS, Ki as defineRecordKinds, O as DEVICE_NONCE_TTL_MS, Q as PREFERENCES_MAX_VALUE_BYTES, Qt as deviceCredentialsCapability, Ta as userError, ei as BaseAddon, et as PreferenceNamespaceSchema, gt as UserRecordSchema, h as CREDENTIAL_TOKEN_AUDIENCE, hn as formatDeviceRevoker, jr as userManagementCapability, kt as buildDeviceEnrollmentLink, lt as SsoBridgeClaimsSchema, mt as TokenScopeSchema, oa as makeSecretMarker, ra as isSecretMarker, st as ScopedTokenSchema, tt as PreferenceValueSchema, wn as isCredentialTokenPayload, wt as authProviderCapability, y as CredentialTokenClaimsSchema } from "../../dist-CdFkkmXW.mjs";
 import { t as require_safe_buffer } from "../../safe-buffer-B1OjL1I9.mjs";
 import { t as require_ms } from "../../ms-CgH2OFlD.mjs";
-import { _ as setProcessJwtSigningKey, a as importDevicePublicKey, c as rebuildDeviceCaCertificate, d as JWT_SIGNING_KEY_REF, g as processJwtSigningKey, h as loadJwtSigningKey, i as generateDeviceCa, l as verifyDeviceLeaf, m as getProcessJwtSigningKeyState, n as DEVICE_CA_KEY_REF, o as issueDeviceLeaf, r as DEVICE_CA_SETTINGS_SECTION, s as loadDeviceCa, t as DEVICE_CA_FIELD, u as verifyDeviceSignature } from "../../device-ca-DYmToMp8.mjs";
+import { _ as setProcessJwtSigningKey, a as importDevicePublicKey, c as rebuildDeviceCaCertificate, d as JWT_SIGNING_KEY_REF, g as processJwtSigningKey, h as loadJwtSigningKey, i as generateDeviceCa, l as verifyDeviceLeaf, m as getProcessJwtSigningKeyState, n as DEVICE_CA_KEY_REF, o as issueDeviceLeaf, r as DEVICE_CA_SETTINGS_SECTION, s as loadDeviceCa, t as DEVICE_CA_FIELD, u as verifyDeviceSignature } from "../../device-ca-BWTWWBcc.mjs";
 import { t as require_read_all_rows } from "../../read-all-rows-TaPqdWNF.mjs";
 import { z } from "zod";
 import * as crypto$1 from "node:crypto";
 import { X509Certificate, createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import nodeCrypto from "crypto";
 import * as path$1 from "node:path";
-import * as fs from "node:fs";
+import * as fs$1 from "node:fs";
 //#region ../../node_modules/bcryptjs/index.js
 /**
 * The random implementation to use as a fallback.
@@ -12064,8 +12064,8 @@ var LocalAuthAddon = class extends BaseAddon {
 					users: this.userManager,
 					dataDir: this.ctx.nodeDataDir,
 					fs: {
-						exists: (filePath) => fs.existsSync(filePath),
-						remove: (filePath) => fs.rmSync(filePath, { force: true })
+						exists: (filePath) => fs$1.existsSync(filePath),
+						remove: (filePath) => fs$1.rmSync(filePath, { force: true })
 					},
 					logger: this.ctx.logger
 				});

package/dist/builtins/local-network/local-network.addon.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DRL3rEfN.js");
-const require_hub_mdns_ciao = require("../../hub-mdns-ciao-DUoTS6jN.js");
+const require_dist = require("../../dist-DX5Fu3mV.js");
+const require_hub_mdns_ciao = require("../../hub-mdns-ciao-C174UDzO.js");
 let zod = require("zod");
 let node_net = require("node:net");
 let node_os = require("node:os");

package/dist/builtins/local-network/local-network.addon.mjs

@@ -1,5 +1,5 @@
-import { $r as errMsg, Da as EventCategory, Fn as localNetworkCapability, Ft as checkRoleAddress, H as HUB_MDNS_TXT_KEYS, Nr as validateCustomAddress, Tn as isDefaultAppConnectionEndpoint, V as HUB_MDNS_SERVICE_TYPE, Z as NetworkTunnelStartedDataSchema, Zn as pickAppLinkHub, c as CAMSTACK_APP_LINK_ORIGIN, ei as BaseAddon, or as resolveAppConnections, pr as resolveNotificationTapAddress, ur as resolveHubAddressRoles, xn as isAppLinkBase, yr as shortHostname } from "../../dist-X1r44BdF.mjs";
-import { P as readLanHttpState, a as storeUploadedCertificate, d as servedHttpsLeafFingerprint, g as readTlsMode, h as readTlsAccessStatus, i as revertToGeneratedCertificate, j as applyLanHttp, k as DEFAULT_LAN_HTTP_PORT, m as readExtraSans, n as applyCertificateToListener, o as useStoredUploadedCertificate, r as regenerateCertificate, t as createCiaoPublisher, v as writeExtraSans, w as ensureTlsCert } from "../../hub-mdns-ciao-CZV5Hion.mjs";
+import { $r as errMsg, Da as EventCategory, Fn as localNetworkCapability, Ft as checkRoleAddress, H as HUB_MDNS_TXT_KEYS, Nr as validateCustomAddress, Tn as isDefaultAppConnectionEndpoint, V as HUB_MDNS_SERVICE_TYPE, Z as NetworkTunnelStartedDataSchema, Zn as pickAppLinkHub, c as CAMSTACK_APP_LINK_ORIGIN, ei as BaseAddon, or as resolveAppConnections, pr as resolveNotificationTapAddress, ur as resolveHubAddressRoles, xn as isAppLinkBase, yr as shortHostname } from "../../dist-CdFkkmXW.mjs";
+import { P as readLanHttpState, a as storeUploadedCertificate, d as servedHttpsLeafFingerprint, g as readTlsMode, h as readTlsAccessStatus, i as revertToGeneratedCertificate, j as applyLanHttp, k as DEFAULT_LAN_HTTP_PORT, m as readExtraSans, n as applyCertificateToListener, o as useStoredUploadedCertificate, r as regenerateCertificate, t as createCiaoPublisher, v as writeExtraSans, w as ensureTlsCert } from "../../hub-mdns-ciao-CYp1Gipm.mjs";
 import { z } from "zod";
 import { isIP } from "node:net";
 import * as os$1 from "node:os";

package/dist/builtins/loki-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DRL3rEfN.js");
+const require_dist = require("../../dist-DX5Fu3mV.js");
 const require_log_read_filter = require("../../log-read-filter-Bi066jwU.js");
 let zod = require("zod");
 //#region src/builtins/loki-logging/loki-payload.ts

package/dist/builtins/loki-logging/index.mjs

@@ -1,4 +1,4 @@
-import { Ln as logDestinationCapability, ei as BaseAddon } from "../../dist-X1r44BdF.mjs";
+import { Ln as logDestinationCapability, ei as BaseAddon } from "../../dist-CdFkkmXW.mjs";
 import { n as compileLogFilter, o as lineMatches } from "../../log-read-filter-D7Ev3zm-.mjs";
 import { z } from "zod";
 //#region src/builtins/loki-logging/loki-payload.ts

package/dist/builtins/native-metrics/native-metrics.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DRL3rEfN.js");
+const require_dist = require("../../dist-DX5Fu3mV.js");
 let node_fs_promises = require("node:fs/promises");
 let node_util = require("node:util");
 let node_os = require("node:os");

package/dist/builtins/native-metrics/native-metrics.addon.mjs

@@ -1,9 +1,9 @@
-import { $r as errMsg, Da as EventCategory, Ui as createEvent, Un as metricsProviderCapability, ei as BaseAddon, ht as UNATTRIBUTED_BUCKET_KEY, ir as reducePoints, mn as foldSnapshotByFunction, rt as ROOT_BUCKET_KEY, sr as resolveBucketMs } from "../../dist-X1r44BdF.mjs";
+import { $r as errMsg, Da as EventCategory, Ui as createEvent, Un as metricsProviderCapability, ei as BaseAddon, ht as UNATTRIBUTED_BUCKET_KEY, ir as reducePoints, mn as foldSnapshotByFunction, rt as ROOT_BUCKET_KEY, sr as resolveBucketMs } from "../../dist-CdFkkmXW.mjs";
 import { access, readFile, readdir } from "node:fs/promises";
 import { promisify } from "node:util";
 import * as os$1 from "node:os";
 import { platform } from "node:os";
-import * as fs from "node:fs";
+import * as fs$1 from "node:fs";
 import { constants, readFileSync } from "node:fs";
 import { execFile, execFileSync } from "node:child_process";
 //#region src/builtins/native-metrics/cgroup-memory.ts
@@ -1642,7 +1642,7 @@ var NativeMetricsProvider = class {
 		let swapUsedBytes = 0;
 		let swapTotalBytes = 0;
 		if (IS_LINUX) try {
-			const meminfo = fs.readFileSync("/proc/meminfo", "utf-8");
+			const meminfo = fs$1.readFileSync("/proc/meminfo", "utf-8");
 			const swapTotal = parseInt(meminfo.match(/SwapTotal:\s+(\d+)/)?.[1] ?? "0", 10) * 1024;
 			const swapFree = parseInt(meminfo.match(/SwapFree:\s+(\d+)/)?.[1] ?? "0", 10) * 1024;
 			swapTotalBytes = swapTotal;
@@ -1720,7 +1720,7 @@ function sampleMacMemory(provider) {
 }
 function getDiskSpaceInternal(dirPath) {
 	return new Promise((resolve, reject) => {
-		fs.statfs(dirPath, (err, stats) => {
+		fs$1.statfs(dirPath, (err, stats) => {
 			if (err) return reject(err);
 			const totalBytes = stats.blocks * stats.bsize;
 			const availableBytes = stats.bavail * stats.bsize;
@@ -1738,7 +1738,7 @@ function getDiskSpaceInternal(dirPath) {
 async function takeDiskIoSnapshot() {
 	const now = Date.now();
 	if (IS_LINUX) try {
-		const data = fs.readFileSync("/proc/diskstats", "utf-8");
+		const data = fs$1.readFileSync("/proc/diskstats", "utf-8");
 		let readOps = 0, readBytes = 0, writeOps = 0, writeBytes = 0;
 		for (const line of data.split("\n")) {
 			const parts = line.trim().split(/\s+/);
@@ -1769,7 +1769,7 @@ async function takeDiskIoSnapshot() {
 async function takeNetworkIoSnapshot() {
 	const now = Date.now();
 	if (IS_LINUX) try {
-		const data = fs.readFileSync("/proc/net/dev", "utf-8");
+		const data = fs$1.readFileSync("/proc/net/dev", "utf-8");
 		let rxBytes = 0, txBytes = 0, rxPackets = 0, txPackets = 0, rxErrors = 0, txErrors = 0;
 		for (const line of data.split("\n")) {
 			const match = line.match(/^\s*(\w+):\s+(.+)$/);
@@ -1830,7 +1830,7 @@ async function takeNetworkIoSnapshot() {
 }
 async function getCpuTemperatureInternal() {
 	if (IS_LINUX) for (const p of ["/sys/class/thermal/thermal_zone0/temp", "/sys/class/hwmon/hwmon0/temp1_input"]) try {
-		const raw = fs.readFileSync(p, "utf-8").trim();
+		const raw = fs$1.readFileSync(p, "utf-8").trim();
 		const millideg = parseInt(raw, 10);
 		if (!isNaN(millideg)) return Math.round(millideg / 100) / 10;
 	} catch {
@@ -1881,10 +1881,10 @@ function getProcessResources() {
 	let threadCount = 0;
 	if (IS_LINUX) {
 		try {
-			openFds = fs.readdirSync(`/proc/${process.pid}/fd`).length;
+			openFds = fs$1.readdirSync(`/proc/${process.pid}/fd`).length;
 		} catch {}
 		try {
-			const match = fs.readFileSync(`/proc/${process.pid}/status`, "utf-8").match(/Threads:\s+(\d+)/);
+			const match = fs$1.readFileSync(`/proc/${process.pid}/status`, "utf-8").match(/Threads:\s+(\d+)/);
 			if (match) threadCount = parseInt(match[1], 10);
 		} catch {}
 	}
@@ -1899,7 +1899,7 @@ function getProcessResources() {
 function getPressure(resource) {
 	if (!IS_LINUX) return null;
 	try {
-		const data = fs.readFileSync(`/proc/pressure/${resource}`, "utf-8");
+		const data = fs$1.readFileSync(`/proc/pressure/${resource}`, "utf-8");
 		const parseLine = (prefix) => {
 			const match = data.match(new RegExp(`${prefix} avg10=(\\d+\\.\\d+) avg60=(\\d+\\.\\d+) avg300=(\\d+\\.\\d+)`));
 			if (!match) return null;

package/dist/builtins/platform-probe/coral-accelerators.d.ts

@@ -12,7 +12,7 @@ export interface CoralFs {
 	* `null` and an empty listing both mean "the bus is not observable".
 	*/
 	listUsbDevices(): readonly string[] | null;
-	/** Read a `<sysfsNode>/<attr>` value (idVendor / idProduct), trimmed. */
+	/** Read a `<sysfsNode>/<attr>` value (idVendor / idProduct / busnum / devnum), trimmed. */
 	readUsbAttr(device: string, attr: string): string;
 	/** PCI function names under `/sys/bus/pci/devices` (e.g. `0000:03:00.0`). */
 	listPciDevices(): readonly string[];
@@ -20,7 +20,7 @@ export interface CoralFs {
 	readPciAttr(device: string, attr: string): string;
 	/** Entry names under `/sys/class/apex` (the gasket/apex driver: `apex_0`, …). */
 	listApexClass(): readonly string[];
-	/** Whether this process can open a device node for read AND write. */
+	/** Whether this process can open a device node (`/dev/apex_N`, `/dev/bus/usb/…`) for read AND write. */
 	canOpen(path: string): boolean;
 	/** Whether a filesystem path exists (the libedgetpu delegate, `/dev/apex_N`). */
 	exists(path: string): boolean;
@@ -38,7 +38,8 @@ export type CoralUsbBusView = "observed" | "unobservable";
 /**
 * Which evidence decided the Coral answer — logged by the probe so a node
 * that reports (or stops reporting) a Coral says WHY:
-*  - `usb-ids` — a Coral USB id is on the bus;
+*  - `usb-ids` — a Coral USB id is on the bus (usable or not: its device node
+*    decides, see {@link CoralDetection.inaccessibleUsbNodes});
 *  - `pci` — a PCIe/M.2 Coral (usable or not) is on the PCI bus;
 *  - `delegate-fallback` — the USB bus is not observable and the libedgetpu
 *    delegate is installed, so one USB unit is ASSUMED;
@@ -49,6 +50,13 @@ export interface CoralDetection {
 	readonly info: CoralInfo | null;
 	readonly usbBus: CoralUsbBusView;
 	readonly decidedBy: CoralDecision;
+	/**
+	* The device node of every USB Coral sysfs lists but this process cannot
+	* open read/write (`/dev/bus/usb/<BBB>/<DDD>`, or `<sysfs entry>` when
+	* sysfs gave no bus/device number) — the evidence behind a USB
+	* `device-not-accessible`. Empty when every listed stick is usable.
+	*/
+	readonly inaccessibleUsbNodes: readonly string[];
 }
 /**
 * Detect Coral Edge TPUs on USB and PCIe/M.2 — the answer only. See
@@ -58,7 +66,9 @@ export declare function classifyCoralAccelerator(fsx: CoralFs, delegateHost?: Ed
 /**
 * Detect Coral Edge TPUs on USB and PCIe/M.2, with the evidence that decided.
 *
-* - USB: every matching USB device counts (multiple Corals run concurrently).
+* - USB: every matching USB device counts (multiple Corals run concurrently),
+*   usable only if its `/dev/bus/usb/<BBB>/<DDD>` node opens read/write — a
+*   listed stick whose node is missing or refused is `device-not-accessible`.
 * - PCIe: the apex driver's units, each usable only if its device node opens;
 *   a Coral PCI function the driver did not bind is `driver-missing`.
 * - Fallback: when the USB bus is NOT OBSERVABLE (`/sys/bus/usb/devices`