@camstack/system 1.2.416 → 1.2.418

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

@@ -3,8 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DxiDI8hZ.js");
-const require_proc_stat = require("../../proc-stat-DL-WUOhl.js");
+const require_dist = require("../../dist-DVUg8e1T.js");
 let node_fs_promises = require("node:fs/promises");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
@@ -2126,7 +2125,7 @@ var NativeMetricsProvider = class {
 		return getCpuTemperatureInternal();
 	}
 	async getProcessStats(input) {
-		const { getPidStats } = await Promise.resolve().then(() => require("../../resource-monitor-BgWGRxN5.js")).then((n) => n.resource_monitor_exports);
+		const { getPidStats } = await Promise.resolve().then(() => require("../../resource-monitor-mio9dSCT.js")).then((n) => n.resource_monitor_exports);
 		const raw = await getPidStats(input.pids);
 		const result = [];
 		for (const [pid, s] of raw) result.push({
@@ -2462,6 +2461,95 @@ function execAsync(cmd, args, timeoutMs = 5e3) {
 		});
 	});
 }
+/**
+* Parse one `/proc/<pid>/stat` line. `null` for a line that does not parse —
+* a process that exited between the readdir and the read leaves a truncated
+* or empty file, and that is normal, not an error.
+*/
+function parseProcStat(line) {
+	const close = line.lastIndexOf(")");
+	const open = line.indexOf("(");
+	if (close < 0 || open < 0 || close < open) return null;
+	const pid = Number(line.slice(0, open).trim());
+	const comm = line.slice(open + 1, close);
+	const rest = line.slice(close + 1).trim().split(/\s+/);
+	const state = rest[0];
+	const ppid = Number(rest[1]);
+	const pgid = Number(rest[2]);
+	const utime = Number(rest[11]);
+	const stime = Number(rest[12]);
+	const startTicks = Number(rest[19]);
+	const rssPages = Number(rest[21]);
+	if (state === void 0 || state === "") return null;
+	if (![
+		pid,
+		ppid,
+		pgid,
+		utime,
+		stime,
+		startTicks,
+		rssPages
+	].every(Number.isFinite)) return null;
+	return {
+		pid,
+		comm,
+		state,
+		ppid,
+		pgid,
+		ticks: utime + stime,
+		startTicks,
+		rssPages
+	};
+}
+function statusKb(status, key) {
+	const match = status.match(new RegExp(`^${key}:\\s+(\\d+)`, "m"));
+	return match ? parseInt(match[1], 10) * 1024 : void 0;
+}
+/** Read `VmRSS` / `RssAnon` / `RssFile` (kB in the file) out of `/proc/<pid>/status`. */
+function parseProcStatusRss(status) {
+	return {
+		rssBytes: statusKb(status, "VmRSS"),
+		privateBytes: statusKb(status, "RssAnon"),
+		sharedBytes: statusKb(status, "RssFile")
+	};
+}
+/** Seconds the process has been alive — `ps etime`, whole seconds. */
+function elapsedSecSince(input) {
+	return Math.max(0, Math.floor(input.uptimeSec - input.startTicks / 100));
+}
+/**
+* `ps pcpu`: CPU time over elapsed time, as a percentage with one decimal.
+*
+* This is deliberately the LIFETIME average `ps` prints, not an instantaneous
+* rate: the columns fed from it have always shown that quantity, and the
+* instantaneous split is a different number with a different owner
+* (`cpuMainPercent` / `cpuGcPercent` from `thread-cpu-sampler.ts`). A process
+* with no elapsed window yet reports 0, never a division by zero.
+*/
+function lifetimeCpuPercent(input) {
+	const elapsedSec = input.uptimeSec - input.startTicks / 100;
+	if (!(elapsedSec > 0)) return 0;
+	const cpuSec = input.ticks / 100;
+	return Math.round(cpuSec / elapsedSec * 1e3) / 10;
+}
+var PID_RE = /^\d+$/;
+var nodeProcReader = {
+	listPids: async () => (await (0, node_fs_promises.readdir)("/proc")).filter((entry) => PID_RE.test(entry)).map((entry) => Number(entry)),
+	readStat: (pid) => (0, node_fs_promises.readFile)(`/proc/${pid}/stat`, "latin1"),
+	readStatus: (pid) => (0, node_fs_promises.readFile)(`/proc/${pid}/status`, "latin1"),
+	readCmdline: (pid) => (0, node_fs_promises.readFile)(`/proc/${pid}/cmdline`, "latin1"),
+	readUptimeSec: async () => {
+		const [first] = (await (0, node_fs_promises.readFile)("/proc/uptime", "latin1")).trim().split(/\s+/);
+		const seconds = Number(first);
+		if (!Number.isFinite(seconds)) throw new Error(`/proc/uptime unreadable: ${String(first)}`);
+		return seconds;
+	}
+};
+/** `ps command=`: argv joined by spaces, or `[comm]` when there is no argv. */
+function commandFromCmdline(cmdline, comm) {
+	const joined = cmdline.split("\0").filter((part) => part.length > 0).join(" ");
+	return joined.length > 0 ? joined : `[${comm}]`;
+}
 //#endregion
 //#region src/builtins/native-metrics/proc-process-table.ts
 /**
@@ -2493,28 +2581,28 @@ async function readProcRow(pid, uptimeSec, reader) {
 	} catch {
 		return null;
 	}
-	const parsed = require_proc_stat.parseProcStat(stat);
+	const parsed = parseProcStat(stat);
 	if (parsed === null) return null;
-	const rss = require_proc_stat.parseProcStatusRss(status);
+	const rss = parseProcStatusRss(status);
 	return {
 		pid: parsed.pid,
 		ppid: parsed.ppid,
 		pgid: parsed.pgid,
-		cpuPercent: require_proc_stat.lifetimeCpuPercent({
+		cpuPercent: lifetimeCpuPercent({
 			ticks: parsed.ticks,
 			startTicks: parsed.startTicks,
 			uptimeSec
 		}),
 		memoryRssBytes: rss.rssBytes ?? 0,
-		uptimeSec: require_proc_stat.elapsedSecSince({
+		uptimeSec: elapsedSecSince({
 			startTicks: parsed.startTicks,
 			uptimeSec
 		}),
-		command: require_proc_stat.commandFromCmdline(cmdline, parsed.comm)
+		command: commandFromCmdline(cmdline, parsed.comm)
 	};
 }
 /** Every process in `/proc`, as the rows `ps -eo …` would have printed. */
-async function readProcProcessTable(reader = require_proc_stat.nodeProcReader) {
+async function readProcProcessTable(reader = nodeProcReader) {
 	const [pids, uptimeSec] = await Promise.all([reader.listPids(), reader.readUptimeSec()]);
 	return (await Promise.all(pids.map((pid) => readProcRow(pid, uptimeSec, reader)))).filter((row) => row !== null);
 }
@@ -2569,7 +2657,7 @@ async function spawnPsTable() {
 }
 var defaultDeps = {
 	platform: (0, node_os.platform)(),
-	reader: require_proc_stat.nodeProcReader,
+	reader: nodeProcReader,
 	spawnPs: spawnPsTable
 };
 /**
@@ -3481,3 +3569,7 @@ var NativeMetricsAddon = class NativeMetricsAddon extends require_dist.BaseAddon
 //#endregion
 exports.NativeMetricsProvider = NativeMetricsProvider;
 exports.default = NativeMetricsAddon;
+exports.lifetimeCpuPercent = lifetimeCpuPercent;
+exports.nodeProcReader = nodeProcReader;
+exports.parseProcStat = parseProcStat;
+exports.parseProcStatusRss = parseProcStatusRss;

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

@@ -1,5 +1,4 @@
-import { Cn as resolveBucketMs, Ft as foldSnapshotByFunction, Or as createEvent, ai as EventCategory, bn as reducePoints, fr as errMsg, pr as BaseAddon, sn as metricsProviderCapability } from "../../dist-DwE9yHdk.mjs";
-import { a as parseProcStat, i as nodeProcReader, n as elapsedSecSince, o as parseProcStatusRss, r as lifetimeCpuPercent, t as commandFromCmdline } from "../../proc-stat-CbC55Kqi.mjs";
+import { Mt as foldSnapshotByFunction, cr as BaseAddon, ei as EventCategory, hn as reducePoints, nn as metricsProviderCapability, sr as errMsg, vn as resolveBucketMs, wr as createEvent } from "../../dist-DlmdESNT.mjs";
 import { access, readFile, readdir } from "node:fs/promises";
 import * as os from "node:os";
 import { platform } from "node:os";
@@ -2121,7 +2120,7 @@ var NativeMetricsProvider = class {
 		return getCpuTemperatureInternal();
 	}
 	async getProcessStats(input) {
-		const { getPidStats } = await import("../../resource-monitor-B2WZ8_q9.mjs").then((n) => n.r);
+		const { getPidStats } = await import("../../resource-monitor-Di9daRwI.mjs").then((n) => n.r);
 		const raw = await getPidStats(input.pids);
 		const result = [];
 		for (const [pid, s] of raw) result.push({
@@ -2457,6 +2456,95 @@ function execAsync(cmd, args, timeoutMs = 5e3) {
 		});
 	});
 }
+/**
+* Parse one `/proc/<pid>/stat` line. `null` for a line that does not parse —
+* a process that exited between the readdir and the read leaves a truncated
+* or empty file, and that is normal, not an error.
+*/
+function parseProcStat(line) {
+	const close = line.lastIndexOf(")");
+	const open = line.indexOf("(");
+	if (close < 0 || open < 0 || close < open) return null;
+	const pid = Number(line.slice(0, open).trim());
+	const comm = line.slice(open + 1, close);
+	const rest = line.slice(close + 1).trim().split(/\s+/);
+	const state = rest[0];
+	const ppid = Number(rest[1]);
+	const pgid = Number(rest[2]);
+	const utime = Number(rest[11]);
+	const stime = Number(rest[12]);
+	const startTicks = Number(rest[19]);
+	const rssPages = Number(rest[21]);
+	if (state === void 0 || state === "") return null;
+	if (![
+		pid,
+		ppid,
+		pgid,
+		utime,
+		stime,
+		startTicks,
+		rssPages
+	].every(Number.isFinite)) return null;
+	return {
+		pid,
+		comm,
+		state,
+		ppid,
+		pgid,
+		ticks: utime + stime,
+		startTicks,
+		rssPages
+	};
+}
+function statusKb(status, key) {
+	const match = status.match(new RegExp(`^${key}:\\s+(\\d+)`, "m"));
+	return match ? parseInt(match[1], 10) * 1024 : void 0;
+}
+/** Read `VmRSS` / `RssAnon` / `RssFile` (kB in the file) out of `/proc/<pid>/status`. */
+function parseProcStatusRss(status) {
+	return {
+		rssBytes: statusKb(status, "VmRSS"),
+		privateBytes: statusKb(status, "RssAnon"),
+		sharedBytes: statusKb(status, "RssFile")
+	};
+}
+/** Seconds the process has been alive — `ps etime`, whole seconds. */
+function elapsedSecSince(input) {
+	return Math.max(0, Math.floor(input.uptimeSec - input.startTicks / 100));
+}
+/**
+* `ps pcpu`: CPU time over elapsed time, as a percentage with one decimal.
+*
+* This is deliberately the LIFETIME average `ps` prints, not an instantaneous
+* rate: the columns fed from it have always shown that quantity, and the
+* instantaneous split is a different number with a different owner
+* (`cpuMainPercent` / `cpuGcPercent` from `thread-cpu-sampler.ts`). A process
+* with no elapsed window yet reports 0, never a division by zero.
+*/
+function lifetimeCpuPercent(input) {
+	const elapsedSec = input.uptimeSec - input.startTicks / 100;
+	if (!(elapsedSec > 0)) return 0;
+	const cpuSec = input.ticks / 100;
+	return Math.round(cpuSec / elapsedSec * 1e3) / 10;
+}
+var PID_RE = /^\d+$/;
+var nodeProcReader = {
+	listPids: async () => (await readdir("/proc")).filter((entry) => PID_RE.test(entry)).map((entry) => Number(entry)),
+	readStat: (pid) => readFile(`/proc/${pid}/stat`, "latin1"),
+	readStatus: (pid) => readFile(`/proc/${pid}/status`, "latin1"),
+	readCmdline: (pid) => readFile(`/proc/${pid}/cmdline`, "latin1"),
+	readUptimeSec: async () => {
+		const [first] = (await readFile("/proc/uptime", "latin1")).trim().split(/\s+/);
+		const seconds = Number(first);
+		if (!Number.isFinite(seconds)) throw new Error(`/proc/uptime unreadable: ${String(first)}`);
+		return seconds;
+	}
+};
+/** `ps command=`: argv joined by spaces, or `[comm]` when there is no argv. */
+function commandFromCmdline(cmdline, comm) {
+	const joined = cmdline.split("\0").filter((part) => part.length > 0).join(" ");
+	return joined.length > 0 ? joined : `[${comm}]`;
+}
 //#endregion
 //#region src/builtins/native-metrics/proc-process-table.ts
 /**
@@ -3474,4 +3562,4 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 	}
 };
 //#endregion
-export { NativeMetricsAddon as default, NativeMetricsProvider as t };
+export { NativeMetricsProvider as a, NativeMetricsAddon as default, parseProcStatusRss as i, nodeProcReader as n, parseProcStat as r, lifetimeCpuPercent as t };

package/dist/builtins/platform-probe/amd-npu.d.ts

@@ -27,3 +27,9 @@ export interface AmdNpuContext {
 * generation so the UI and fleet census can show the hardware.
 */
 export declare function classifyAmdNpu(ctx: AmdNpuContext, fsx: AmdNpuFs): NpuInfo | null;
+/**
+* The NPU descriptor for an AMD PCI device id (`0x1502` or `1502`). Shared by
+* the Linux sysfs probe and the Windows PnP probe so both name the same
+* silicon the same way.
+*/
+export declare function xdnaInfoForDevice(rawDeviceId: string): NpuInfo;

package/dist/builtins/platform-probe/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DxiDI8hZ.js");
+const require_dist = require("../../dist-DVUg8e1T.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -59,7 +59,257 @@ function classifyCoralAccelerator(fsx) {
 	return null;
 }
 //#endregion
+//#region src/builtins/platform-probe/amd-npu.ts
+var amd_npu_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	classifyAmdNpu: () => classifyAmdNpu,
+	xdnaInfoForDevice: () => xdnaInfoForDevice
+});
+var ACCEL_CLASS = "/sys/class/accel";
+var ACCEL_DEV = "/dev/accel";
+var AMD_PCI_VENDOR = "0x1022";
+/** Phoenix / Hawk Point XDNA1. */
+var XDNA1_DEVICES = new Set(["0x1502"]);
+/** Strix / Krackan XDNA2. */
+var XDNA2_DEVICES = new Set(["0x17f0"]);
+function normalizePciId(raw) {
+	const t = raw.trim().toLowerCase();
+	if (t.startsWith("0x")) return t;
+	if (t.length > 0 && [...t].every((c) => "0123456789abcdef".includes(c))) return "0x" + t;
+	return t;
+}
+function hasAccelCharDevice(fsx) {
+	if (fsx.listDir(ACCEL_DEV).some((n) => n.startsWith("accel"))) return true;
+	return fsx.exists("/dev/accel/accel0");
+}
+/**
+* Detect an AMD XDNA NPU and report it as **present only**.
+*
+* Inference is NOT offered until P2 (Ryzen AI on Linux is Strix-first;
+* Phoenix is not a production path today). The probe still names the
+* generation so the UI and fleet census can show the hardware.
+*/
+function classifyAmdNpu(ctx, fsx) {
+	if (ctx.platform !== "linux" || ctx.arch !== "x64" || !ctx.amdPresent) return null;
+	if (!hasAccelCharDevice(fsx)) return null;
+	for (const name of fsx.listDir(ACCEL_CLASS)) {
+		if (!name.startsWith("accel")) continue;
+		const vendor = normalizePciId(fsx.readFile("/sys/class/accel/" + name + "/device/vendor"));
+		const device = normalizePciId(fsx.readFile("/sys/class/accel/" + name + "/device/device"));
+		if (vendor !== AMD_PCI_VENDOR) continue;
+		return xdnaInfoForDevice(device);
+	}
+	return null;
+}
+/**
+* The NPU descriptor for an AMD PCI device id (`0x1502` or `1502`). Shared by
+* the Linux sysfs probe and the Windows PnP probe so both name the same
+* silicon the same way.
+*/
+function xdnaInfoForDevice(rawDeviceId) {
+	const device = normalizePciId(rawDeviceId);
+	if (XDNA1_DEVICES.has(device)) return {
+		type: "amd-xdna",
+		name: "AMD XDNA1 NPU",
+		generation: "xdna1"
+	};
+	if (XDNA2_DEVICES.has(device)) return {
+		type: "amd-xdna",
+		name: "AMD XDNA2 NPU",
+		generation: "xdna2"
+	};
+	return {
+		type: "amd-xdna",
+		name: "AMD XDNA NPU"
+	};
+}
+//#endregion
+//#region src/builtins/platform-probe/windows-hardware.ts
+var PCI_VENDOR_NVIDIA = "10DE";
+var PCI_VENDOR_INTEL = "8086";
+/** Radeon graphics are 1002; the XDNA NPU is a 1022 device. */
+var PCI_VENDORS_AMD = new Set(["1002", "1022"]);
+/** Adapters that are not hardware: RDP, hypervisor, capture and spoofing drivers. */
+var VIRTUAL_ADAPTER = /basic display|basic render|remote display|hyper-v|vmware|virtualbox|parallels|citrix|parsec|indirect display|displaylink|mirror driver|virtual/i;
+/** One PowerShell process answers both: video controllers and AMD PCI devices. */
+var POWERSHELL_SCRIPT = [
+	"$ErrorActionPreference = 'SilentlyContinue'",
+	"$gpu = @(Get-CimInstance Win32_VideoController | Select-Object Name, PNPDeviceID)",
+	"$npu = @(Get-CimInstance Win32_PnPEntity | Where-Object { $_.PNPDeviceID -match 'VEN_1022&DEV_(1502|17F0)' } | Select-Object Name, PNPDeviceID)",
+	"@{ gpu = $gpu; npu = $npu } | ConvertTo-Json -Compress -Depth 3"
+].join("; ");
+function powershellInvocation(systemRoot) {
+	return [`${systemRoot ?? "C:\\Windows"}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, [
+		"-NoProfile",
+		"-NonInteractive",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-Command",
+		POWERSHELL_SCRIPT
+	]];
+}
+var WMIC_VIDEO_ARGS = [
+	"path",
+	"Win32_VideoController",
+	"get",
+	"Name,PNPDeviceID",
+	"/format:csv"
+];
+var WMIC_AMD_PNP_ARGS = [
+	"path",
+	"Win32_PnPEntity",
+	"where",
+	"PNPDeviceID like 'PCI\\\\VEN_1022&DEV_%'",
+	"get",
+	"Name,PNPDeviceID",
+	"/format:csv"
+];
+function asRecordList(value) {
+	if (Array.isArray(value)) return value.filter((v) => v !== null && typeof v === "object" && !Array.isArray(v));
+	return value !== null && typeof value === "object" ? [Object.fromEntries(Object.entries(value))] : [];
+}
+function str(value) {
+	return typeof value === "string" ? value : "";
+}
+/** PowerShell prepends a BOM on some hosts, which `JSON.parse` rejects. */
+function parseJson(text) {
+	return JSON.parse(text.replace(/^\uFEFF/, "").trim());
+}
+/**
+* `{"gpu":[...],"npu":[...]}` as the script emits it. A single result comes
+* back as an object rather than a one-element array, and an empty one as
+* `null` — all three are handled.
+*/
+function parsePowershellOutput(text) {
+	const root = parseJson(text);
+	const gpu = root !== null && typeof root === "object" ? Reflect.get(root, "gpu") : void 0;
+	const npu = root !== null && typeof root === "object" ? Reflect.get(root, "npu") : void 0;
+	const toDevice = (r) => ({
+		name: str(r["Name"]),
+		pnpDeviceId: str(r["PNPDeviceID"])
+	});
+	return {
+		controllers: asRecordList(gpu).map(toDevice),
+		pnp: asRecordList(npu).map(toDevice)
+	};
+}
+/**
+* `wmic ... /format:csv` — a blank line, then `Node,<cols alphabetical>`, then
+* one row per object. The device name can contain commas, so only the FIRST
+* column boundaries are trusted: columns after `Node` are `Name,PNPDeviceID`
+* and the PNP id (no commas) is taken from the END of the row.
+*/
+function parseWmicCsv(text) {
+	const lines = text.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+	const headerIndex = lines.findIndex((l) => /^node,/i.test(l));
+	if (headerIndex < 0) return [];
+	const out = [];
+	for (const line of lines.slice(headerIndex + 1)) {
+		const parts = line.split(",");
+		if (parts.length < 3) continue;
+		const pnpDeviceId = (parts[parts.length - 1] ?? "").trim();
+		const name = parts.slice(1, -1).join(",").trim();
+		if (pnpDeviceId.length > 0) out.push({
+			name,
+			pnpDeviceId
+		});
+	}
+	return out;
+}
+/** The PCI vendor id (`10DE`) out of a PnP id like `PCI\VEN_10DE&DEV_2504&...`. */
+function pciVendorOf(pnpDeviceId) {
+	const m = /VEN_([0-9A-F]{4})/i.exec(pnpDeviceId);
+	return m?.[1] ? m[1].toUpperCase() : null;
+}
+function pciDeviceOf(pnpDeviceId) {
+	const m = /DEV_([0-9A-F]{4})/i.exec(pnpDeviceId);
+	return m?.[1] ? m[1].toLowerCase() : null;
+}
+function gpuVendor(c) {
+	const vendor = pciVendorOf(c.pnpDeviceId);
+	if (vendor === PCI_VENDOR_NVIDIA) return "nvidia";
+	if (vendor === PCI_VENDOR_INTEL) return "intel";
+	if (vendor !== null && PCI_VENDORS_AMD.has(vendor)) return "amd";
+	if (/nvidia|geforce|quadro|rtx/i.test(c.name)) return "nvidia";
+	if (/intel/i.test(c.name)) return "intel";
+	if (/amd|radeon/i.test(c.name)) return "amd";
+	return null;
+}
+/**
+* The accelerator the node should treat as its GPU. Same preference as the
+* Linux probe — NVIDIA, then Intel, then AMD — so a laptop with an Intel iGPU
+* and a discrete card is described the way the rest of the system already
+* expects. Virtual adapters never count.
+*/
+function classifyWindowsGpu(controllers) {
+	const real = controllers.filter((c) => c.name.length > 0 && !VIRTUAL_ADAPTER.test(c.name));
+	for (const wanted of [
+		"nvidia",
+		"intel",
+		"amd"
+	]) {
+		const hit = real.find((c) => gpuVendor(c) === wanted);
+		if (hit) return {
+			type: wanted,
+			name: hit.name
+		};
+	}
+	return null;
+}
+/**
+* An AMD XDNA NPU from PnP ids: `PCI\VEN_1022&DEV_1502` (Phoenix / Hawk Point)
+* or `DEV_17F0` (Strix / Krackan). Present-only, exactly like the Linux probe.
+*/
+function classifyWindowsAmdNpu(devices) {
+	for (const d of devices) {
+		if (pciVendorOf(d.pnpDeviceId) !== "1022") continue;
+		const device = pciDeviceOf(d.pnpDeviceId);
+		if (device === "1502" || device === "17f0") return xdnaInfoForDevice(device);
+	}
+	return null;
+}
+async function viaPowershell(run, systemRoot) {
+	const [file, args] = powershellInvocation(systemRoot);
+	const parsed = parsePowershellOutput(await run(file, args));
+	return {
+		gpu: classifyWindowsGpu(parsed.controllers),
+		npu: classifyWindowsAmdNpu(parsed.pnp),
+		source: "powershell"
+	};
+}
+async function viaWmic(run) {
+	const [video, amd] = await Promise.all([run("wmic", WMIC_VIDEO_ARGS), run("wmic", WMIC_AMD_PNP_ARGS).catch(() => "")]);
+	return {
+		gpu: classifyWindowsGpu(parseWmicCsv(video)),
+		npu: classifyWindowsAmdNpu(parseWmicCsv(amd)),
+		source: "wmic"
+	};
+}
+/**
+* GPU + AMD NPU on a Windows host. NEVER throws: a probe that cannot run is
+* `{ gpu: null, npu: null, source: 'none' }` and boot goes on — the node then
+* scores as a CPU node, which is correct for hardware we could not see.
+*/
+async function probeWindowsHardware(run, options = {}) {
+	try {
+		return await viaPowershell(run, options.systemRoot);
+	} catch (powershellError) {
+		options.onFallback?.(`PowerShell probe failed (${powershellError instanceof Error ? powershellError.message : String(powershellError)}); trying wmic`);
+	}
+	try {
+		return await viaWmic(run);
+	} catch (wmicError) {
+		options.onFallback?.(`wmic probe failed (${wmicError instanceof Error ? wmicError.message : String(wmicError)}); hardware unknown`);
+		return {
+			gpu: null,
+			npu: null,
+			source: "none"
+		};
+	}
+}
+//#endregion
 //#region src/builtins/platform-probe/platform-scorer.ts
+/** WMI can be slow on a cold machine, but never worth stalling boot for. */
+var WINDOWS_PROBE_TIMEOUT_MS = 15e3;
 /**
 * Promisified `execFile`. Used across the scorer so every subprocess
 * spawn yields the event loop — critical at boot because a single sync
@@ -237,24 +487,25 @@ var PlatformScorer = class {
 			};
 			npu = { type: "apple-ane" };
 		}
+		if (platform === "win32") {
+			const nvidia = await this.probeNvidiaSmi();
+			const win = await this.probeWindowsHardwareSafely();
+			gpu = nvidia ?? win.gpu;
+			npu = win.npu;
+			if (gpu) this.logger.info("Windows GPU detected", { meta: {
+				type: gpu.type,
+				name: gpu.name
+			} });
+			if (npu && win.source !== "none") this.logger.info("AMD XDNA NPU detected (present only)", { meta: {
+				type: npu.type,
+				name: npu.name,
+				generation: npu.generation,
+				source: win.source
+			} });
+		}
 		if (platform === "linux") {
-			try {
-				const { stdout } = await execFileAsync("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
-					encoding: "utf8",
-					timeout: 5e3
-				});
-				const output = stdout.trim();
-				if (output) {
-					const [name, mem] = output.split(",").map((s) => s.trim());
-					gpu = {
-						type: "nvidia",
-						name: name ?? "NVIDIA GPU",
-						memoryMB: parseInt(mem ?? "0")
-					};
-				}
-			} catch (err) {
-				this.logger.debug("NVIDIA GPU detection failed", { meta: { error: require_dist.errMsg(err) } });
-			}
+			const nvidia = await this.probeNvidiaSmi();
+			if (nvidia) gpu = nvidia;
 			const listRenderNodes = () => {
 				try {
 					return node_fs.readdirSync("/dev/dri").filter((n) => n.startsWith("renderD")).map((n) => `/dev/dri/${n}`);
@@ -313,7 +564,7 @@ var PlatformScorer = class {
 				} });
 			}
 			if (!npu) {
-				const { classifyAmdNpu } = await Promise.resolve().then(() => require("../../amd-npu-B-QyyMyF.js"));
+				const { classifyAmdNpu } = await Promise.resolve().then(() => amd_npu_exports);
 				npu = classifyAmdNpu({
 					platform,
 					arch,
@@ -348,6 +599,53 @@ var PlatformScorer = class {
 			coral
 		};
 	}
+	/** NVIDIA's own tool: exact model and VRAM. Null when absent or failing. */
+	async probeNvidiaSmi() {
+		try {
+			const { stdout } = await execFileAsync("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
+				encoding: "utf8",
+				timeout: 5e3,
+				windowsHide: true
+			});
+			const output = stdout.trim();
+			if (!output) return null;
+			const [name, mem] = output.split(",").map((s) => s.trim());
+			return {
+				type: "nvidia",
+				name: name ?? "NVIDIA GPU",
+				memoryMB: parseInt(mem ?? "0")
+			};
+		} catch (err) {
+			this.logger.debug("NVIDIA GPU detection failed", { meta: { error: require_dist.errMsg(err) } });
+			return null;
+		}
+	}
+	/** Windows WMI probe; bounded, and a failure is a log line, never a boot failure. */
+	async probeWindowsHardwareSafely() {
+		const run = async (file, args) => {
+			const { stdout } = await execFileAsync(file, [...args], {
+				encoding: "utf8",
+				timeout: WINDOWS_PROBE_TIMEOUT_MS,
+				windowsHide: true,
+				maxBuffer: 4 * 1024 * 1024
+			});
+			return stdout;
+		};
+		const systemRoot = process.env["SystemRoot"];
+		try {
+			return await probeWindowsHardware(run, {
+				...systemRoot === void 0 ? {} : { systemRoot },
+				onFallback: (reason) => this.logger.warn("Windows hardware probe degraded", { meta: { reason } })
+			});
+		} catch (err) {
+			this.logger.warn("Windows hardware probe failed — scoring as a CPU node", { meta: { error: require_dist.errMsg(err) } });
+			return {
+				gpu: null,
+				npu: null,
+				source: "none"
+			};
+		}
+	}
 	/**
 	* Locates a Python interpreter without importing any module.
 	*