@camstack/system 1.2.390 → 1.2.392

package/dist/builtins/native-metrics/thread-cpu-sampler.d.ts

@@ -1,116 +1,116 @@
 /** Raw tick counts for one process at one instant, already classified. */
 export interface ThreadTickSample {
-    /** Sum of utime+stime over threads that are NOT in the V8 helper pool. */
-    readonly mainTicks: number;
-    /** Sum of utime+stime over the V8 helper-pool threads. */
-    readonly gcTicks: number;
-    /** Number of threads seen, both classes together. */
-    readonly threadCount: number;
-    /** `Date.now()` at the moment the sample was taken. */
-    readonly atMs: number;
-    /**
-     * The process's `starttime` (field 22 of `/proc/<pid>/stat`) — jiffies since
-     * boot at which THIS incarnation of the pid began. Read from the main
-     * thread, whose tid equals the pid.
-     *
-     * It is the process's identity, and it is the only thing that distinguishes
-     * "the same process, later" from "a different process that got the same pid".
-     * `null` when the main thread's stat could not be read, which is also
-     * treated as "identity unknown" — see {@link cpuSplitBetween}.
-     */
-    readonly startTicks: number | null;
+	/** Sum of utime+stime over threads that are NOT in the V8 helper pool. */
+	readonly mainTicks: number;
+	/** Sum of utime+stime over the V8 helper-pool threads. */
+	readonly gcTicks: number;
+	/** Number of threads seen, both classes together. */
+	readonly threadCount: number;
+	/** `Date.now()` at the moment the sample was taken. */
+	readonly atMs: number;
+	/**
+	* The process's `starttime` (field 22 of `/proc/<pid>/stat`) — jiffies since
+	* boot at which THIS incarnation of the pid began. Read from the main
+	* thread, whose tid equals the pid.
+	*
+	* It is the process's identity, and it is the only thing that distinguishes
+	* "the same process, later" from "a different process that got the same pid".
+	* `null` when the main thread's stat could not be read, which is also
+	* treated as "identity unknown" — see {@link cpuSplitBetween}.
+	*/
+	readonly startTicks: number | null;
 }
 /** The CPU split over the window between two {@link ThreadTickSample}s. */
 export interface ThreadCpuSplit {
-    /** CPU% of the process's own threads. 100 = one core saturated. */
-    readonly mainPercent: number;
-    /** CPU% of the V8 helper pool — see the module docblock on what this holds. */
-    readonly gcPercent: number;
-    /** Threads seen in the newer sample. */
-    readonly threadCount: number;
+	/** CPU% of the process's own threads. 100 = one core saturated. */
+	readonly mainPercent: number;
+	/** CPU% of the V8 helper pool — see the module docblock on what this holds. */
+	readonly gcPercent: number;
+	/** Threads seen in the newer sample. */
+	readonly threadCount: number;
 }
 /**
- * Parse one `/proc/<pid>/task/<tid>/stat` line.
- *
- * The `comm` field is field 2 and is wrapped in parentheses — and it can
- * itself contain spaces and parentheses (`(V8Worker)`, but also
- * `(some (weird) name)`). Splitting the line on whitespace therefore corrupts
- * every field after it. The only correct parse is to cut at the LAST `)`, take
- * `comm` from inside the parens, and index the remaining fields from there:
- * after the cut, field 3 (`state`) is index 0, so `utime` (field 14) is index
- * 11 and `stime` (field 15) is index 12.
- *
- * `starttime` is field 22, so index 19 by the same arithmetic. It is the
- * thread's own start, which for the main thread (tid == pid) is the PROCESS's
- * start — the identity {@link cpuSplitBetween} checks before it believes a
- * window belongs to the process it belonged to last time.
- *
- * Returns `null` for a line that does not parse — a thread that exited between
- * the readdir and the read leaves a truncated or empty file, and that is
- * normal, not an error.
- */
+* Parse one `/proc/<pid>/task/<tid>/stat` line.
+*
+* The `comm` field is field 2 and is wrapped in parentheses — and it can
+* itself contain spaces and parentheses (`(V8Worker)`, but also
+* `(some (weird) name)`). Splitting the line on whitespace therefore corrupts
+* every field after it. The only correct parse is to cut at the LAST `)`, take
+* `comm` from inside the parens, and index the remaining fields from there:
+* after the cut, field 3 (`state`) is index 0, so `utime` (field 14) is index
+* 11 and `stime` (field 15) is index 12.
+*
+* `starttime` is field 22, so index 19 by the same arithmetic. It is the
+* thread's own start, which for the main thread (tid == pid) is the PROCESS's
+* start — the identity {@link cpuSplitBetween} checks before it believes a
+* window belongs to the process it belonged to last time.
+*
+* Returns `null` for a line that does not parse — a thread that exited between
+* the readdir and the read leaves a truncated or empty file, and that is
+* normal, not an error.
+*/
 export interface ParsedThreadStat {
-    readonly comm: string;
-    readonly ticks: number;
-    /** Field 22 (`starttime`), in jiffies since boot. */
-    readonly startTicks: number;
+	readonly comm: string;
+	readonly ticks: number;
+	/** Field 22 (`starttime`), in jiffies since boot. */
+	readonly startTicks: number;
 }
 export declare function parseThreadStat(line: string): ParsedThreadStat | null;
 /** Injectable procfs surface — the whole reason this module is testable. */
 export interface ProcFsReader {
-    readonly listTaskIds: (pid: number) => Promise<readonly string[]>;
-    readonly readTaskStat: (pid: number, tid: string) => Promise<string>;
+	readonly listTaskIds: (pid: number) => Promise<readonly string[]>;
+	readonly readTaskStat: (pid: number, tid: string) => Promise<string>;
 }
 export declare const nodeProcFsReader: ProcFsReader;
 /**
- * Read one instant's tick counts for `pid`, or `null` when the process has no
- * readable `/proc/<pid>/task` — it exited, we lack permission, or this is not
- * Linux. `null` is "unknown"; it must never be turned into a zero downstream.
- */
+* Read one instant's tick counts for `pid`, or `null` when the process has no
+* readable `/proc/<pid>/task` — it exited, we lack permission, or this is not
+* Linux. `null` is "unknown"; it must never be turned into a zero downstream.
+*/
 export declare function readThreadTicks(pid: number, reader?: ProcFsReader): Promise<ThreadTickSample | null>;
 /**
- * The CPU split between two samples of the SAME process.
- *
- * Returns `null` — never a zero — when the window cannot produce a rate:
- *  - the two samples are not separated in time (no window to divide by);
- *  - the pid's `starttime` changed, or is unknown on either side. A changed
- *    starttime means the pid was RECYCLED: this is a different process that
- *    happens to wear the same number. See below for why the tick check alone
- *    does not catch it;
- *  - either tick count went BACKWARDS, which is the same fault seen from the
- *    other side. A negative delta divided by a window would render as a
- *    plausible small number for the wrong process, and a plausible wrong
- *    number is the failure this whole surface exists to avoid.
- *
- * ## Why `starttime` and not just the backwards-tick check
- *
- * The backwards check only fires when the NEW process has burned FEWER ticks
- * than the dead one had. A recycled pid landing on a busier process — an
- * ffmpeg that has been transcoding for a minute inheriting the pid of an
- * ffmpeg that idled — produces a large POSITIVE delta, which divides cleanly
- * and renders as a spike. That is not a hypothetical rounding concern now that
- * the process snapshot attributes each pid to a camera: it would charge one
- * camera for another camera's whole lifetime of CPU, in a chart built
- * specifically to answer "why is 617 worse than 615". `starttime` is the pid's
- * incarnation number and it catches both directions.
- */
+* The CPU split between two samples of the SAME process.
+*
+* Returns `null` — never a zero — when the window cannot produce a rate:
+*  - the two samples are not separated in time (no window to divide by);
+*  - the pid's `starttime` changed, or is unknown on either side. A changed
+*    starttime means the pid was RECYCLED: this is a different process that
+*    happens to wear the same number. See below for why the tick check alone
+*    does not catch it;
+*  - either tick count went BACKWARDS, which is the same fault seen from the
+*    other side. A negative delta divided by a window would render as a
+*    plausible small number for the wrong process, and a plausible wrong
+*    number is the failure this whole surface exists to avoid.
+*
+* ## Why `starttime` and not just the backwards-tick check
+*
+* The backwards check only fires when the NEW process has burned FEWER ticks
+* than the dead one had. A recycled pid landing on a busier process — an
+* ffmpeg that has been transcoding for a minute inheriting the pid of an
+* ffmpeg that idled — produces a large POSITIVE delta, which divides cleanly
+* and renders as a spike. That is not a hypothetical rounding concern now that
+* the process snapshot attributes each pid to a camera: it would charge one
+* camera for another camera's whole lifetime of CPU, in a chart built
+* specifically to answer "why is 617 worse than 615". `starttime` is the pid's
+* incarnation number and it catches both directions.
+*/
 export declare function cpuSplitBetween(prev: ThreadTickSample, next: ThreadTickSample): ThreadCpuSplit | null;
 /**
- * Keeps the previous tick sample per pid so the next process-snapshot tick can
- * turn it into a rate.
- *
- * Bounded by construction: {@link sample} replaces the whole map with only the
- * pids it was just asked about, so a pid that stops appearing in the scan is
- * dropped on the following tick rather than accumulating forever.
- */
+* Keeps the previous tick sample per pid so the next process-snapshot tick can
+* turn it into a rate.
+*
+* Bounded by construction: {@link sample} replaces the whole map with only the
+* pids it was just asked about, so a pid that stops appearing in the scan is
+* dropped on the following tick rather than accumulating forever.
+*/
 export declare class ThreadCpuTracker {
-    private readonly reader;
-    private previous;
-    constructor(reader?: ProcFsReader);
-    /**
-     * Sample `pids` and return the split for each one that HAS a usable previous
-     * sample. A pid absent from the result has no answer yet — the caller must
-     * report `null`, not `0`.
-     */
-    sample(pids: readonly number[]): Promise<ReadonlyMap<number, ThreadCpuSplit>>;
+	private readonly reader;
+	private previous;
+	constructor(reader?: ProcFsReader);
+	/**
+	* Sample `pids` and return the split for each one that HAS a usable previous
+	* sample. A pid absent from the result has no answer yet — the caller must
+	* report `null`, not `0`.
+	*/
+	sample(pids: readonly number[]): Promise<ReadonlyMap<number, ThreadCpuSplit>>;
 }

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

@@ -0,0 +1,15 @@
+import type { GpuInfo } from "@camstack/types";
+/**
+* Filesystem seam for AMD iGPU detection — mirrors intel-accelerators.ts
+* so the classifier stays a pure, unit-testable function over injected reads.
+*/
+export interface AmdAcceleratorFs {
+	listRenderNodes(): readonly string[];
+	readVendor(renderNode: string): string;
+	/** PCI device id (0x15bf), empty when unreadable. */
+	readDevice(renderNode: string): string;
+}
+export interface AmdAccelerators {
+	gpu: GpuInfo | null;
+}
+export declare function classifyAmdAccelerators(fsx: AmdAcceleratorFs): AmdAccelerators;

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

@@ -0,0 +1,29 @@
+import type { NpuInfo } from "@camstack/types";
+/**
+* Filesystem seam for AMD XDNA NPU detection. Sysfs under
+* /sys/class/accel/accelN/device/{vendor,device} names the PCI ids; the
+* char device is /dev/accel/accelN.
+*/
+export interface AmdNpuFs {
+	listDir(path: string): readonly string[];
+	exists(path: string): boolean;
+	/** Read a sysfs attribute; empty string when missing. */
+	readFile(path: string): string;
+}
+export interface AmdNpuContext {
+	readonly platform: "darwin" | "linux" | "win32";
+	readonly arch: "arm64" | "x64";
+	/**
+	* True when an AMD CPU or AMD iGPU is present. A stray accel node on a
+	* non-AMD host must not be reported as XDNA.
+	*/
+	readonly amdPresent: boolean;
+}
+/**
+* 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.
+*/
+export declare function classifyAmdNpu(ctx: AmdNpuContext, fsx: AmdNpuFs): NpuInfo | null;

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

@@ -1,22 +1,22 @@
-import { CoralInfo } from '@camstack/types';
+import type { CoralInfo } from "@camstack/types";
 /**
- * Filesystem seam for Coral USB Edge TPU detection — mirrors the
- * `AcceleratorFs` pattern in `intel-accelerators.ts` so the classifier stays a
- * pure, unit-testable function over injected reads.
- */
+* Filesystem seam for Coral USB Edge TPU detection — mirrors the
+* `AcceleratorFs` pattern in `intel-accelerators.ts` so the classifier stays a
+* pure, unit-testable function over injected reads.
+*/
 export interface CoralFs {
-    /** USB device directory names under `/sys/bus/usb/devices` (e.g. `2-4`). */
-    listUsbDevices(): readonly string[];
-    /** Read a `<sysfsNode>/<attr>` value (idVendor / idProduct), trimmed. */
-    readUsbAttr(device: string, attr: string): string;
-    /** Whether a filesystem path exists (the libedgetpu delegate). */
-    exists(path: string): boolean;
+	/** USB device directory names under `/sys/bus/usb/devices` (e.g. `2-4`). */
+	listUsbDevices(): readonly string[];
+	/** Read a `<sysfsNode>/<attr>` value (idVendor / idProduct), trimmed. */
+	readUsbAttr(device: string, attr: string): string;
+	/** Whether a filesystem path exists (the libedgetpu delegate). */
+	exists(path: string): boolean;
 }
 /**
- * Detect a Coral USB Edge TPU. Present when EITHER a matching USB device is
- * enumerated OR the libedgetpu delegate is installed (the delegate is the
- * hub-provisioned runtime prerequisite; on a container whose `/sys` USB view is
- * limited, its presence is a reliable operator-intent signal that the Coral is
- * wired through). Returns `null` when neither signal is found.
- */
+* Detect a Coral USB Edge TPU. Present when EITHER a matching USB device is
+* enumerated OR the libedgetpu delegate is installed (the delegate is the
+* hub-provisioned runtime prerequisite; on a container whose `/sys` USB view is
+* limited, its presence is a reliable operator-intent signal that the Coral is
+* wired through). Returns `null` when neither signal is found.
+*/
 export declare function classifyCoralAccelerator(fsx: CoralFs): CoralInfo | null;

package/dist/builtins/platform-probe/index.d.ts

@@ -1,33 +1,41 @@
-import { ProviderRegistration, BaseAddon } from '@camstack/types';
-export { PlatformScorer } from './platform-scorer.js';
-export { InferenceConfigResolver } from './inference-config-resolver.js';
+/**
+* Platform-probe core builtin.
+*
+* Infra addon — probes hardware + inference runtimes on the local node and
+* exposes the result via the `platform-probe` capability (singleton per
+* node).
+*/
+import type { ProviderRegistration } from "@camstack/types";
+import { BaseAddon } from "@camstack/types";
+export { PlatformScorer } from "./platform-scorer.js";
+export { InferenceConfigResolver } from "./inference-config-resolver.js";
 export declare class PlatformProbeNativeAddon extends BaseAddon {
-    private scorer;
-    private cachedCaps;
-    /**
-     * Per-boot generation stamp for the manual readiness emissions below.
-     * Constant for the lifetime of this addon instance (== one process boot);
-     * consumer-side registries derive a monotonic epoch from generation
-     * transitions. Mirrors `BaseAddon._readinessGeneration` (private there).
-     */
-    private readonly readinessGeneration;
-    constructor();
-    /**
-     * Manual readiness protocol. The provider registers synchronously from
-     * `onInitialize`, but the REAL hardware + EP scoring is the async
-     * `probePromise` (embedded-Python install included). The BaseAddon
-     * auto-emit would flip `ready` at registration time — BEFORE any
-     * accelerator is visible — so probe-gated consumers (detection-pipeline
-     * engine auto-pick) would read accelerator-blind results and stick on
-     * onnx-CPU. Instead: `starting` at init, the single authoritative
-     * `ready` once the probe resolves, `down` on shutdown.
-     */
-    protected get autoEmitReadiness(): boolean;
-    /** Bare cluster node id — readiness is scoped `{type:'node', nodeId}`. */
-    private bareLocalNodeId;
-    /** Emit a `system.ready-state` transition for the platform-probe cap. */
-    private emitProbeReadiness;
-    protected onInitialize(): Promise<ProviderRegistration[]>;
-    protected onShutdown(): Promise<void>;
+	private scorer;
+	private cachedCaps;
+	/**
+	* Per-boot generation stamp for the manual readiness emissions below.
+	* Constant for the lifetime of this addon instance (== one process boot);
+	* consumer-side registries derive a monotonic epoch from generation
+	* transitions. Mirrors `BaseAddon._readinessGeneration` (private there).
+	*/
+	private readonly readinessGeneration;
+	constructor();
+	/**
+	* Manual readiness protocol. The provider registers synchronously from
+	* `onInitialize`, but the REAL hardware + EP scoring is the async
+	* `probePromise` (embedded-Python install included). The BaseAddon
+	* auto-emit would flip `ready` at registration time — BEFORE any
+	* accelerator is visible — so probe-gated consumers (detection-pipeline
+	* engine auto-pick) would read accelerator-blind results and stick on
+	* onnx-CPU. Instead: `starting` at init, the single authoritative
+	* `ready` once the probe resolves, `down` on shutdown.
+	*/
+	protected override get autoEmitReadiness(): boolean;
+	/** Bare cluster node id — readiness is scoped `{type:'node', nodeId}`. */
+	private bareLocalNodeId;
+	/** Emit a `system.ready-state` transition for the platform-probe cap. */
+	private emitProbeReadiness;
+	protected onInitialize(): Promise<ProviderRegistration[]>;
+	protected onShutdown(): Promise<void>;
 }
 export default PlatformProbeNativeAddon;

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-8LQ4lDEB.js");
+const require_dist = require("../../dist-XTkzsnz-.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -255,27 +255,47 @@ var PlatformScorer = class {
 			} catch (err) {
 				this.logger.debug("NVIDIA GPU detection failed", { meta: { error: require_dist.errMsg(err) } });
 			}
+			const listRenderNodes = () => {
+				try {
+					return node_fs.readdirSync("/dev/dri").filter((n) => n.startsWith("renderD")).map((n) => `/dev/dri/${n}`);
+				} catch {
+					return [];
+				}
+			};
+			const readDrmAttr = (node, attr) => {
+				try {
+					return node_fs.readFileSync(`/sys/class/drm/${node.split("/").pop()}/device/${attr}`, "utf8");
+				} catch {
+					return "";
+				}
+			};
 			if (!gpu) {
 				const { classifyIntelAccelerators } = await Promise.resolve().then(() => require("../../intel-accelerators-BvBjZn4j.js"));
 				const intel = classifyIntelAccelerators({
-					listRenderNodes: () => {
-						try {
-							return node_fs.readdirSync("/dev/dri").filter((n) => n.startsWith("renderD")).map((n) => `/dev/dri/${n}`);
-						} catch {
-							return [];
-						}
-					},
-					readVendor: (node) => {
-						try {
-							return node_fs.readFileSync(`/sys/class/drm/${node.split("/").pop()}/device/vendor`, "utf8");
-						} catch {
-							return "";
-						}
-					}
+					listRenderNodes,
+					readVendor: (node) => readDrmAttr(node, "vendor")
 				});
 				gpu = gpu ?? intel.gpu;
 				if (intel.gpu) this.logger.info("Intel iGPU detected", { meta: { name: intel.gpu.name } });
 			}
+			if (!gpu) {
+				const { classifyAmdAccelerators } = await Promise.resolve().then(() => require("../../amd-accelerators-CEuPFBBK.js"));
+				const amd = classifyAmdAccelerators({
+					listRenderNodes,
+					readVendor: (node) => readDrmAttr(node, "vendor"),
+					readDevice: (node) => readDrmAttr(node, "device")
+				});
+				gpu = gpu ?? amd.gpu;
+				if (amd.gpu) this.logger.info("AMD iGPU detected", { meta: { name: amd.gpu.name } });
+			}
+			const listDir = (p) => {
+				try {
+					return node_fs.readdirSync(p);
+				} catch {
+					return [];
+				}
+			};
+			const exists = (p) => node_fs.existsSync(p);
 			if (!npu) {
 				const { classifyIntelNpu } = await Promise.resolve().then(() => require("../../intel-npu-DYF5hO5K.js"));
 				npu = classifyIntelNpu({
@@ -283,19 +303,36 @@ var PlatformScorer = class {
 					arch,
 					intelPresent: gpu?.type === "intel" || /intel/i.test(cpuModel)
 				}, {
-					listDir: (p) => {
+					listDir,
+					exists
+				});
+				if (npu) this.logger.info("Intel NPU detected", { meta: {
+					type: npu.type,
+					name: npu.name,
+					device: "/dev/accel/accel*"
+				} });
+			}
+			if (!npu) {
+				const { classifyAmdNpu } = await Promise.resolve().then(() => require("../../amd-npu-B-QyyMyF.js"));
+				npu = classifyAmdNpu({
+					platform,
+					arch,
+					amdPresent: gpu?.type === "amd" || /amd|ryzen/i.test(cpuModel)
+				}, {
+					listDir,
+					exists,
+					readFile: (p) => {
 						try {
-							return node_fs.readdirSync(p);
+							return node_fs.readFileSync(p, "utf8");
 						} catch {
-							return [];
+							return "";
 						}
-					},
-					exists: (p) => node_fs.existsSync(p)
+					}
 				});
-				if (npu) this.logger.info("Intel NPU detected", { meta: {
+				if (npu) this.logger.info("AMD XDNA NPU detected (present only)", { meta: {
 					type: npu.type,
 					name: npu.name,
-					device: "/dev/accel/accel*"
+					generation: npu.generation
 				} });
 			}
 		}

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

@@ -1,5 +1,5 @@
 import { o as __toESM } from "../../chunk-CNf5ZN-e.mjs";
-import { hn as platformProbeCapability, jn as scoreRuntimes, kr as emitReadiness, lr as errMsg, ni as EventCategory, ur as BaseAddon, wt as enumerateInferenceDevices } from "../../dist-Biqn3TEn.mjs";
+import { hn as platformProbeCapability, jn as scoreRuntimes, kr as emitReadiness, lr as errMsg, ni as EventCategory, ur as BaseAddon, wt as enumerateInferenceDevices } from "../../dist-byg8IP4Q.mjs";
 import * as os from "node:os";
 import * as fs from "node:fs";
 import { execFile } from "node:child_process";
@@ -249,27 +249,47 @@ var PlatformScorer = class {
 			} catch (err) {
 				this.logger.debug("NVIDIA GPU detection failed", { meta: { error: errMsg(err) } });
 			}
+			const listRenderNodes = () => {
+				try {
+					return fs.readdirSync("/dev/dri").filter((n) => n.startsWith("renderD")).map((n) => `/dev/dri/${n}`);
+				} catch {
+					return [];
+				}
+			};
+			const readDrmAttr = (node, attr) => {
+				try {
+					return fs.readFileSync(`/sys/class/drm/${node.split("/").pop()}/device/${attr}`, "utf8");
+				} catch {
+					return "";
+				}
+			};
 			if (!gpu) {
 				const { classifyIntelAccelerators } = await import("../../intel-accelerators-idEumqk1.mjs");
 				const intel = classifyIntelAccelerators({
-					listRenderNodes: () => {
-						try {
-							return fs.readdirSync("/dev/dri").filter((n) => n.startsWith("renderD")).map((n) => `/dev/dri/${n}`);
-						} catch {
-							return [];
-						}
-					},
-					readVendor: (node) => {
-						try {
-							return fs.readFileSync(`/sys/class/drm/${node.split("/").pop()}/device/vendor`, "utf8");
-						} catch {
-							return "";
-						}
-					}
+					listRenderNodes,
+					readVendor: (node) => readDrmAttr(node, "vendor")
 				});
 				gpu = gpu ?? intel.gpu;
 				if (intel.gpu) this.logger.info("Intel iGPU detected", { meta: { name: intel.gpu.name } });
 			}
+			if (!gpu) {
+				const { classifyAmdAccelerators } = await import("../../amd-accelerators-U_RsoEDd.mjs");
+				const amd = classifyAmdAccelerators({
+					listRenderNodes,
+					readVendor: (node) => readDrmAttr(node, "vendor"),
+					readDevice: (node) => readDrmAttr(node, "device")
+				});
+				gpu = gpu ?? amd.gpu;
+				if (amd.gpu) this.logger.info("AMD iGPU detected", { meta: { name: amd.gpu.name } });
+			}
+			const listDir = (p) => {
+				try {
+					return fs.readdirSync(p);
+				} catch {
+					return [];
+				}
+			};
+			const exists = (p) => fs.existsSync(p);
 			if (!npu) {
 				const { classifyIntelNpu } = await import("../../intel-npu-C8HKvRQF.mjs");
 				npu = classifyIntelNpu({
@@ -277,19 +297,36 @@ var PlatformScorer = class {
 					arch,
 					intelPresent: gpu?.type === "intel" || /intel/i.test(cpuModel)
 				}, {
-					listDir: (p) => {
+					listDir,
+					exists
+				});
+				if (npu) this.logger.info("Intel NPU detected", { meta: {
+					type: npu.type,
+					name: npu.name,
+					device: "/dev/accel/accel*"
+				} });
+			}
+			if (!npu) {
+				const { classifyAmdNpu } = await import("../../amd-npu-Db_SoSuL.mjs");
+				npu = classifyAmdNpu({
+					platform,
+					arch,
+					amdPresent: gpu?.type === "amd" || /amd|ryzen/i.test(cpuModel)
+				}, {
+					listDir,
+					exists,
+					readFile: (p) => {
 						try {
-							return fs.readdirSync(p);
+							return fs.readFileSync(p, "utf8");
 						} catch {
-							return [];
+							return "";
 						}
-					},
-					exists: (p) => fs.existsSync(p)
+					}
 				});
-				if (npu) this.logger.info("Intel NPU detected", { meta: {
+				if (npu) this.logger.info("AMD XDNA NPU detected (present only)", { meta: {
 					type: npu.type,
 					name: npu.name,
-					device: "/dev/accel/accel*"
+					generation: npu.generation
 				} });
 			}
 		}