@camstack/system 1.2.389 → 1.2.391

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/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/inference-config-resolver.d.ts

@@ -1,29 +1,29 @@
-import { PlatformScore, HardwareInfo, ModelRequirement, ResolvedInferenceConfig } from '@camstack/types';
+import type { PlatformScore, HardwareInfo, ModelRequirement, ResolvedInferenceConfig } from "@camstack/types";
 export declare class InferenceConfigResolver {
-    private readonly scores;
-    private readonly hardware;
-    constructor(scores: readonly PlatformScore[], hardware: HardwareInfo);
-    /**
-     * Compute accuracy/backend weights based on available system RAM.
-     * availableRAM_MB is now sourced from systeminformation (reliable cross-platform),
-     * not os.freemem() which is broken on macOS.
-     *
-     * - > 16 GB available: prefer larger, more accurate models (accuracy 0.6, backend 0.4)
-     * - > 8 GB available:  balanced (accuracy 0.5, backend 0.5)
-     * - <= 8 GB available: prefer speed (accuracy 0.4, backend 0.6)
-     */
-    private getWeights;
-    /**
-     * Given an addon's model requirements, pick the best model + runtime + backend.
-     *
-     * Algorithm:
-     * 1. Filter models by available RAM (minRAM_MB < 25% of available RAM)
-     * 2. For each remaining model, find the best platform score whose format
-     *    is available in the model's formats
-     * 3. Pick the model with the highest combined score using RAM-adaptive weights:
-     *    - High RAM (>16 GB): accuracy × 0.6 + backend × 0.4  (prefer accuracy)
-     *    - Mid RAM  (>8 GB):  accuracy × 0.5 + backend × 0.5  (balanced)
-     *    - Low RAM  (<=8 GB): accuracy × 0.4 + backend × 0.6  (prefer speed)
-     */
-    resolve(requirements: readonly ModelRequirement[]): ResolvedInferenceConfig;
+	private readonly scores;
+	private readonly hardware;
+	constructor(scores: readonly PlatformScore[], hardware: HardwareInfo);
+	/**
+	* Compute accuracy/backend weights based on available system RAM.
+	* availableRAM_MB is now sourced from systeminformation (reliable cross-platform),
+	* not os.freemem() which is broken on macOS.
+	*
+	* - > 16 GB available: prefer larger, more accurate models (accuracy 0.6, backend 0.4)
+	* - > 8 GB available:  balanced (accuracy 0.5, backend 0.5)
+	* - <= 8 GB available: prefer speed (accuracy 0.4, backend 0.6)
+	*/
+	private getWeights;
+	/**
+	* Given an addon's model requirements, pick the best model + runtime + backend.
+	*
+	* Algorithm:
+	* 1. Filter models by available RAM (minRAM_MB < 25% of available RAM)
+	* 2. For each remaining model, find the best platform score whose format
+	*    is available in the model's formats
+	* 3. Pick the model with the highest combined score using RAM-adaptive weights:
+	*    - High RAM (>16 GB): accuracy × 0.6 + backend × 0.4  (prefer accuracy)
+	*    - Mid RAM  (>8 GB):  accuracy × 0.5 + backend × 0.5  (balanced)
+	*    - Low RAM  (<=8 GB): accuracy × 0.4 + backend × 0.6  (prefer speed)
+	*/
+	resolve(requirements: readonly ModelRequirement[]): ResolvedInferenceConfig;
 }

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

@@ -1,14 +1,14 @@
-import { GpuInfo } from '@camstack/types';
+import type { GpuInfo } from "@camstack/types";
 /**
- * Filesystem seam for Intel iGPU detection — the classifier stays a pure,
- * unit-testable function over injected reads. The Intel NPU ("AI Boost") is a
- * separate DRM accel device with its own classifier — see `intel-npu.ts`.
- */
+* Filesystem seam for Intel iGPU detection — the classifier stays a pure,
+* unit-testable function over injected reads. The Intel NPU ("AI Boost") is a
+* separate DRM accel device with its own classifier — see `intel-npu.ts`.
+*/
 export interface AcceleratorFs {
-    listRenderNodes(): readonly string[];
-    readVendor(renderNode: string): string;
+	listRenderNodes(): readonly string[];
+	readVendor(renderNode: string): string;
 }
 export interface IntelAccelerators {
-    gpu: GpuInfo | null;
+	gpu: GpuInfo | null;
 }
 export declare function classifyIntelAccelerators(fsx: AcceleratorFs): IntelAccelerators;

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

@@ -1,38 +1,38 @@
-import { NpuInfo } from '@camstack/types';
+import type { NpuInfo } from "@camstack/types";
 /**
- * Filesystem seam for Intel NPU detection — mirrors the `AcceleratorFs` /
- * `CoralFs` pattern so the classifier stays a pure, unit-testable function over
- * injected reads.
- */
+* Filesystem seam for Intel NPU detection — mirrors the `AcceleratorFs` /
+* `CoralFs` pattern so the classifier stays a pure, unit-testable function over
+* injected reads.
+*/
 export interface NpuFs {
-    /**
-     * Directory entries under a path (e.g. the accel char devices under
-     * `/dev/accel`). MUST return an empty list when the directory is absent.
-     */
-    listDir(path: string): readonly string[];
-    /** Whether a filesystem path exists. */
-    exists(path: string): boolean;
+	/**
+	* Directory entries under a path (e.g. the accel char devices under
+	* `/dev/accel`). MUST return an empty list when the directory is absent.
+	*/
+	listDir(path: string): readonly string[];
+	/** Whether a filesystem path exists. */
+	exists(path: string): boolean;
 }
 /** Everything the NPU classifier needs to know about the host, beside the FS. */
 export interface IntelNpuContext {
-    readonly platform: 'darwin' | 'linux' | 'win32';
-    readonly arch: 'arm64' | 'x64';
-    /**
-     * True when an Intel CPU or Intel iGPU is present. The NPU ("AI Boost") is an
-     * Intel-only accelerator, so a stray `/dev/accel` node on a non-Intel host
-     * (e.g. some other DRM accel driver) must NOT be misread as an Intel NPU.
-     */
-    readonly intelPresent: boolean;
+	readonly platform: "darwin" | "linux" | "win32";
+	readonly arch: "arm64" | "x64";
+	/**
+	* True when an Intel CPU or Intel iGPU is present. The NPU ("AI Boost") is an
+	* Intel-only accelerator, so a stray `/dev/accel` node on a non-Intel host
+	* (e.g. some other DRM accel driver) must NOT be misread as an Intel NPU.
+	*/
+	readonly intelPresent: boolean;
 }
 /**
- * Detect the Intel NPU ("AI Boost", the `intel_vpu` kernel driver).
- *
- * On Linux the NPU surfaces as a DRM accel char device `/dev/accel/accel*`.
- * Detection is gated on linux + x64 + an Intel CPU/iGPU being present — the NPU
- * only ships on x86_64 Intel Core Ultra (Meteor/Arrow Lake+) parts, so those
- * three conditions together make a matching accel node an Intel NPU.
- *
- * Returns `null` when any gate fails or no accel node is found. The caller must
- * NOT clobber an already-resolved NPU (e.g. `apple-ane` on macOS).
- */
+* Detect the Intel NPU ("AI Boost", the `intel_vpu` kernel driver).
+*
+* On Linux the NPU surfaces as a DRM accel char device `/dev/accel/accel*`.
+* Detection is gated on linux + x64 + an Intel CPU/iGPU being present — the NPU
+* only ships on x86_64 Intel Core Ultra (Meteor/Arrow Lake+) parts, so those
+* three conditions together make a matching accel node an Intel NPU.
+*
+* Returns `null` when any gate fails or no accel node is found. The caller must
+* NOT clobber an already-resolved NPU (e.g. `apple-ane` on macOS).
+*/
 export declare function classifyIntelNpu(ctx: IntelNpuContext, fsx: NpuFs): NpuInfo | null;

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

@@ -1,37 +1,37 @@
-import { HardwareInfo, PlatformCapabilities, IScopedLogger } from '@camstack/types';
+import type { HardwareInfo, PlatformCapabilities, IScopedLogger } from "@camstack/types";
 export declare class PlatformScorer {
-    private cached;
-    private readonly logger;
-    /**
-     * Path to the embedded portable Python (from `ctx.deps.ensurePython()`).
-     * The Docker hub ships NO system `python3` — inference runs on the
-     * downloaded portable build — so probing system `python3`/`python` would
-     * wrongly report "Python not found". When set, the interpreter lookup
-     * tries THIS binary first; `null` falls back to a system `python3`/`python`
-     * lookup (dev / agent environments where Python is on PATH).
-     */
-    private readonly embeddedPythonPath;
-    constructor(logger?: IScopedLogger, embeddedPythonPath?: string | null);
-    /**
-     * Probe hardware + derive scores from pure rules and score all backend combos.
-     *
-     * An optional `onPhase` callback is invoked at each step so consumers
-     * (e.g. the platform-probe addon) can emit live progress events on
-     * the event bus. The callback takes a phase id + a typed payload; all
-     * phases fire in strict order: `started` → `hardware` → `scored` → `done`.
-     * On failure, `error` fires once with the exception. Cached after first call.
-     *
-     * Scores are hardware-driven only (no Python module import subprocess):
-     * `scoreRuntimes` from `@camstack/types` is the single source of truth.
-     */
-    probe(onPhase?: (phase: string, payload?: Record<string, unknown>) => void): Promise<PlatformCapabilities>;
-    probeHardware(): Promise<HardwareInfo>;
-    /**
-     * Locates a Python interpreter without importing any module.
-     *
-     * Tries: embedded path (if configured) → `python3` → `python`.
-     * Returns the first executable found, or `null` if none respond.
-     * MUST NOT run `-c "import ..."` — interpreter location only.
-     */
-    private resolvePythonPath;
+	private cached;
+	private readonly logger;
+	/**
+	* Path to the embedded portable Python (from `ctx.deps.ensurePython()`).
+	* The Docker hub ships NO system `python3` — inference runs on the
+	* downloaded portable build — so probing system `python3`/`python` would
+	* wrongly report "Python not found". When set, the interpreter lookup
+	* tries THIS binary first; `null` falls back to a system `python3`/`python`
+	* lookup (dev / agent environments where Python is on PATH).
+	*/
+	private readonly embeddedPythonPath;
+	constructor(logger?: IScopedLogger, embeddedPythonPath?: string | null);
+	/**
+	* Probe hardware + derive scores from pure rules and score all backend combos.
+	*
+	* An optional `onPhase` callback is invoked at each step so consumers
+	* (e.g. the platform-probe addon) can emit live progress events on
+	* the event bus. The callback takes a phase id + a typed payload; all
+	* phases fire in strict order: `started` → `hardware` → `scored` → `done`.
+	* On failure, `error` fires once with the exception. Cached after first call.
+	*
+	* Scores are hardware-driven only (no Python module import subprocess):
+	* `scoreRuntimes` from `@camstack/types` is the single source of truth.
+	*/
+	probe(onPhase?: (phase: string, payload?: Record<string, unknown>) => void): Promise<PlatformCapabilities>;
+	probeHardware(): Promise<HardwareInfo>;
+	/**
+	* Locates a Python interpreter without importing any module.
+	*
+	* Tries: embedded path (if configured) → `python3` → `python`.
+	* Returns the first executable found, or `null` if none respond.
+	* MUST NOT run `-c "import ..."` — interpreter location only.
+	*/
+	private resolvePythonPath;
 }

package/dist/builtins/platform-probe/runtime-packages.d.ts

@@ -1,6 +1,6 @@
-import { HardwareInfo } from '@camstack/types';
+import type { HardwareInfo } from "@camstack/types";
 export interface RuntimePackageSet {
-    requirementsFiles: string[];
-    backendIds: string[];
+	requirementsFiles: string[];
+	backendIds: string[];
 }
 export declare function resolveRuntimePackages(hardware: HardwareInfo): RuntimePackageSet;