@ciphore/radiocli 0.2.2 → 0.2.4

package/dist/platform/packages.js

@@ -0,0 +1,216 @@
+import { commandExists } from './executables.js';
+import { powershellCommand } from './shell.js';
+import { identifyPlatform, readLinuxOsRelease } from './runtime.js';
+export const packageManagers = ['brew', 'winget', 'scoop', 'choco', 'apt', 'dnf', 'pacman', 'apk', 'zypper', 'pkg', 'pkg_add', 'pkgin', 'termux-pkg', 'pkgman'];
+/** FreeBSD pkg and Termux pkg have distinct recipes and privilege models. */
+export function packageManagerProgram(manager) {
+    return manager === 'termux-pkg' ? 'pkg' : manager;
+}
+/** Package names/options are selected from the recipes below, never shell input. */
+export function packageCommandInvocation(command, platform, resolve = () => null) {
+    const program = resolve(command.program) ?? command.program;
+    const args = (command.program === 'sudo' || command.program === 'doas') && command.args[0]
+        ? [resolve(command.args[0]) ?? command.args[0], ...command.args.slice(1)]
+        : command.args;
+    return platform === 'win32'
+        ? { program: resolve('powershell.exe') ?? 'powershell.exe', args: powershellCommand([program, ...args]) }
+        : { program, args };
+}
+export function detectPackageManager(platform, osRelease, hasCommand = commandExists, env = process.env) {
+    const host = identifyPlatform({ platform, osRelease, env });
+    if (host.id === 'termux')
+        return hasCommand('pkg') ? 'termux-pkg' : null;
+    if (platform === 'darwin')
+        return hasCommand('brew') ? 'brew' : null;
+    if (platform === 'win32')
+        return firstAvailable(['winget', 'scoop', 'choco'], hasCommand);
+    if (platform === 'freebsd')
+        return hasCommand('pkg') ? 'pkg' : null;
+    if (platform === 'openbsd')
+        return hasCommand('pkg_add') ? 'pkg_add' : null;
+    // pkg on Solaris/illumos is IPS, not the FreeBSD installer.
+    if (platform === 'netbsd' || platform === 'sunos')
+        return hasCommand('pkgin') ? 'pkgin' : null;
+    if (platform === 'haiku')
+        return hasCommand('pkgman') ? 'pkgman' : null;
+    if (platform !== 'linux')
+        return null;
+    const ids = linuxReleaseIds(osRelease);
+    const preferred = hasAny(ids, ['debian', 'ubuntu', 'linuxmint', 'pop'])
+        ? ['apt']
+        : hasAny(ids, ['fedora', 'rhel', 'centos'])
+            ? ['dnf']
+            : hasAny(ids, ['arch', 'manjaro'])
+                ? ['pacman']
+                : hasAny(ids, ['alpine'])
+                    ? ['apk']
+                    : hasAny(ids, ['opensuse', 'suse'])
+                        ? ['zypper']
+                        : ['apt', 'dnf', 'pacman', 'apk', 'zypper'];
+    return firstAvailable(preferred, hasCommand);
+}
+export function packageInstallCommand(manager, component, { elevation = 'sudo' } = {}) {
+    const packages = {
+        winget: { mpv: 'shinchiro.mpv', ffmpeg: 'Gyan.FFmpeg', vlc: 'VideoLAN.VLC' },
+        // pkgsrc FFmpeg/ffplay packages and executables carry a major version.
+        // Choose an available matching pair manually instead of guessing a catalog.
+        pkgin: { mpv: 'mpv', vlc: 'vlc' },
+        // Termux's main ffmpeg package omits ffplay. Enabling x11-repo and its
+        // display/audio services is an explicit manual step, not a setup side effect.
+        'termux-pkg': { mpv: 'mpv' },
+        pkgman: { mpv: 'mpv', ffmpeg: 'ffmpeg8_tools' }
+    };
+    const packageName = packages[manager] ? packages[manager][component] : component;
+    if (!packageName)
+        return null;
+    let program = packageManagerProgram(manager);
+    let args;
+    if (manager === 'brew')
+        args = ['install', component === 'vlc' ? '--cask' : packageName, ...(component === 'vlc' ? [packageName] : [])];
+    else if (manager === 'winget')
+        args = ['install', '--id', packageName, '-e', '--accept-package-agreements', '--accept-source-agreements'];
+    else if (manager === 'scoop')
+        args = ['install', packageName];
+    else if (manager === 'choco')
+        args = ['install', packageName, '-y'];
+    else if (manager === 'apt') {
+        program = 'apt-get';
+        args = ['install', '-y', packageName];
+    }
+    else if (manager === 'pacman')
+        args = ['-S', '--needed', '--noconfirm', packageName];
+    else if (manager === 'apk')
+        args = ['add', packageName];
+    else if (manager === 'zypper')
+        args = ['--non-interactive', 'install', packageName];
+    else if (manager === 'dnf' || manager === 'pkg' || manager === 'termux-pkg' || manager === 'pkgman')
+        args = ['install', '-y', packageName];
+    else if (manager === 'pkg_add')
+        args = ['-I', packageName];
+    else
+        args = ['-y', 'install', packageName];
+    if (packageManagerNeedsRoot(manager) && elevation) {
+        args = [program, ...args];
+        program = elevation;
+    }
+    return { component, label: componentLabel(component), program, args, display: [program, ...args].join(' ') };
+}
+export function packageManagerNeedsRoot(manager) {
+    return !['brew', 'winget', 'scoop', 'choco', 'termux-pkg', 'pkgman'].includes(manager);
+}
+export function packageManagerNotes(manager, host = identifyPlatform()) {
+    if (manager === 'termux-pkg' || (!manager && host.id === 'termux'))
+        return [
+            'Termux pkg runs as the normal app user, without sudo or root. Use --package-manager=termux-pkg to select this recipe explicitly.',
+            'The Termux ffmpeg package does not include ffplay. The separate ffplay package needs x11-repo and a configured display/audio environment; mpv is the recommended audio player.',
+            'Android clipboard integration requires the termux-api package and a compatible Termux:API app; helper execution can still fail if Android denies access.'
+        ];
+    if (manager === 'pkgman' || (!manager && host.id === 'haiku'))
+        return [
+            'The verified HaikuPorts runtime recipe provides Node 20, below RadioCLI\'s Node 22 minimum. These playback recipes do not resolve that runtime blocker; a separate working Node 22+ port is required.',
+            'Haiku ffmpeg8_tools provides ffmpeg and ffplay. A secondary-architecture install may require explicit RADIOCLI_FFMPEG_PATH and RADIOCLI_FFPLAY_PATH values.'
+        ];
+    if (host.id === 'aix')
+        return ['There is no verified AIX mpv or ffplay package recipe. Provision a working native player manually and set RADIOCLI_MPV_PATH or RADIOCLI_FFPLAY_PATH; IBM Toolbox DNF availability does not establish a playback package.'];
+    if (manager === 'pkg')
+        return ['FreeBSD ffmpeg provides ffplay only when built with SDL; verify the executable separately.'];
+    if (manager === 'pkgin' || host.id === 'sunos')
+        return [
+            ...(host.id === 'sunos' ? ['Solaris/illumos setup uses an existing pkgsrc/pkgin installation. IPS pkg is a different tool and is not used by this recipe.'] : []),
+            'pkgsrc uses versioned FFmpeg/ffplay packages. Choose a matching available pair and set RADIOCLI_FFPLAY_PATH to the absolute ffplay executable.'
+        ];
+    return [];
+}
+export function platformLabel(platform, osRelease, env = process.env) {
+    if (identifyPlatform({ platform, osRelease, env }).id === 'termux')
+        return 'Android / Termux';
+    if (platform === 'darwin')
+        return `${process.arch === 'arm64' ? 'macOS Apple Silicon' : 'macOS'}`;
+    if (platform === 'win32')
+        return 'Windows';
+    if (platform === 'haiku')
+        return 'Haiku';
+    if (platform === 'sunos')
+        return 'Solaris / illumos';
+    if (platform === 'aix')
+        return 'AIX';
+    if (platform === 'android')
+        return 'Android';
+    if (platform === 'linux')
+        return osReleaseValue(osRelease, 'PRETTY_NAME') || 'Linux';
+    return platform;
+}
+export function componentLabel(component) {
+    if (component === 'ffmpeg')
+        return 'FFmpeg / ffplay';
+    if (component === 'vlc')
+        return 'VLC fallback';
+    return 'mpv';
+}
+function firstAvailable(values, hasCommand) {
+    return values.find(hasCommand) ?? null;
+}
+function linuxReleaseIds(osRelease) {
+    const ids = new Set();
+    for (const line of osRelease.split('\n')) {
+        const match = /^(ID|ID_LIKE)=(.*)$/.exec(line);
+        if (!match)
+            continue;
+        for (const value of match[2].replaceAll('"', '').split(/\s+/))
+            if (value.trim())
+                ids.add(value.trim().toLowerCase());
+    }
+    return ids;
+}
+function osReleaseValue(osRelease, key) {
+    const line = osRelease.split('\n').find(candidate => candidate.startsWith(`${key}=`));
+    return line?.slice(key.length + 1).replace(/^"|"$/g, '') ?? '';
+}
+function hasAny(values, candidates) {
+    return candidates.some(candidate => values.has(candidate));
+}
+export function packageManagerElevation(hasCommand, isRoot) {
+    return isRoot ? null : firstAvailable(['sudo', 'doas'], hasCommand);
+}
+export function packageInstallPrerequisites(manager, components) {
+    if (manager !== 'scoop' || !components.some(component => component === 'mpv' || component === 'vlc'))
+        return [];
+    return [{ component: null, label: 'Scoop extras bucket', program: 'scoop', args: ['bucket', 'add', 'extras'], display: 'scoop bucket add extras' }];
+}
+export function mpvInstallCommand(platform = process.platform, osRelease = readLinuxOsRelease(platform), env = process.env, options = {}) {
+    return playbackInstallHint('mpv', platform, osRelease, env, options);
+}
+export function ffplayInstallCommand(platform = process.platform, osRelease = readLinuxOsRelease(platform), env = process.env, options = {}) {
+    return playbackInstallHint('ffmpeg', platform, osRelease, env, options);
+}
+function playbackInstallHint(component, platform, osRelease, env, { hasCommand = commandExists, getUid = process.getuid }) {
+    const host = identifyPlatform({ platform, osRelease, env });
+    const player = component === 'mpv' ? 'mpv' : 'ffplay';
+    if (host.id === 'aix')
+        return `manual native player required; no verified AIX ${player} package recipe (set RADIOCLI_${player.toUpperCase()}_PATH)`;
+    const manager = detectPackageManager(platform, osRelease, hasCommand, env);
+    if (component === 'ffmpeg' && host.id === 'termux')
+        return `enable x11-repo manually, then ${manager ? 'pkg install -y ffplay' : 'install the separate ffplay package manually'} (requires configured display/audio); use mpv for audio`;
+    if (component === 'ffmpeg' && (platform === 'netbsd' || platform === 'sunos'))
+        return 'manually install a matching pkgsrc ffmpegN/ffplayN pair; set RADIOCLI_FFPLAY_PATH';
+    const notes = [];
+    if (component === 'ffmpeg' && platform === 'freebsd')
+        notes.push('ffplay requires the SDL build option');
+    if (!manager)
+        return [`install ${component === 'mpv' ? 'mpv' : 'FFmpeg'} manually; no supported package manager was found`, ...notes].join('; ');
+    const isRoot = getUid?.() === 0;
+    const elevation = packageManagerElevation(hasCommand, isRoot);
+    const command = packageInstallCommand(manager, component, { elevation });
+    if (!command)
+        return `install ${componentLabel(component)} manually`;
+    if (packageManagerNeedsRoot(manager) && !isRoot && !elevation)
+        notes.unshift('run as root; sudo/doas unavailable');
+    if (manager === 'pkgin')
+        notes.push('requires configured pkgsrc');
+    if (manager === 'termux-pkg' && isRoot)
+        notes.push('run as the normal Termux app user, without root');
+    const prerequisites = packageInstallPrerequisites(manager, [component]);
+    for (const prerequisite of prerequisites)
+        notes.push(`first run ${prerequisite.display}`);
+    return command.display + (notes.length ? ` (${notes.join('; ')})` : '');
+}

package/dist/platform/paths.js

@@ -0,0 +1,40 @@
+import { homedir } from 'node:os';
+import { posix, win32 } from 'node:path';
+/** Path selectors form one launch identity, including selectors that are absent. */
+export const pathEnvironmentKeys = [
+    'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA',
+    'RADIOCLI_HOME', 'RADIO_ATLAS_HOME',
+    'XDG_DATA_HOME', 'XDG_CACHE_HOME', 'XDG_RUNTIME_DIR'
+];
+/**
+ * Keep historical namespaces stable. In particular, macOS alarm-control/Guard
+ * files and general agent/occurrence runtime files already use different roots.
+ * Moving either would strand active authenticated sessions during an upgrade.
+ */
+export function platformPaths({ platform = process.platform, home = homedir(), env = process.env } = {}) {
+    const path = platform === 'win32' ? win32 : posix;
+    const dataRoot = platform === 'darwin' ? path.join(home, 'Library', 'Application Support')
+        : platform === 'win32' ? env.APPDATA ?? path.join(home, 'AppData', 'Roaming')
+            : env.XDG_DATA_HOME ?? path.join(home, '.local', 'share');
+    const cacheRoot = platform === 'darwin' ? path.join(home, 'Library', 'Caches')
+        : platform === 'win32' ? env.LOCALAPPDATA ?? path.join(home, 'AppData', 'Local')
+            : env.XDG_CACHE_HOME ?? path.join(home, '.cache');
+    const appName = platform === 'win32' ? 'RadioCLI' : 'radiocli';
+    const legacyRoot = platform === 'darwin' ? path.join(home, 'Library', 'Application Support') : env.XDG_DATA_HOME ?? path.join(home, '.local', 'share');
+    const legacyCacheRoot = platform === 'darwin' ? legacyRoot : env.XDG_CACHE_HOME ?? path.join(home, '.cache');
+    const override = env.RADIOCLI_HOME || env.RADIO_ATLAS_HOME;
+    const overrideName = env.RADIOCLI_HOME ? 'radiocli' : 'radio-atlas';
+    const library = override ? path.join(override, `${overrideName}.json`) : path.join(dataRoot, appName, 'radiocli.json');
+    const cache = override ? path.join(override, `${overrideName}-cache.json`) : path.join(cacheRoot, appName, 'radiocli-cache.json');
+    const runtime = env.RADIOCLI_HOME ? path.join(env.RADIOCLI_HOME, 'runtime')
+        : platform === 'win32' ? path.join(cacheRoot, appName, 'runtime')
+            : path.join(env.XDG_RUNTIME_DIR ?? path.join(home, '.local', 'state'), 'radiocli');
+    return {
+        library,
+        legacyLibrary: override ? library : path.join(legacyRoot, 'radio-atlas', 'radio-atlas.json'),
+        cache,
+        legacyCache: override ? cache : path.join(legacyCacheRoot, 'radio-atlas', 'radio-atlas-cache.json'),
+        runtime,
+        alarmRuntime: !env.RADIOCLI_HOME && platform === 'darwin' ? path.join(dataRoot, 'radiocli', 'runtime') : runtime
+    };
+}

package/dist/platform/runtime.js

@@ -0,0 +1,67 @@
+import { readFileSync } from 'node:fs';
+import { endianness, release } from 'node:os';
+const knownPlatforms = new Set(['darwin', 'win32', 'linux', 'freebsd', 'openbsd', 'netbsd', 'android', 'haiku', 'sunos', 'aix']);
+/** Host facts are independent from service readiness and project support tiers. */
+export function identifyPlatform(input = {}) {
+    const platform = input.platform ?? process.platform;
+    const env = input.env ?? process.env;
+    const termux = (platform === 'android' || platform === 'linux') && Boolean(env.TERMUX_VERSION || env.PREFIX?.match(/^\/data\/(?:data|user\/\d+)\/com\.termux(?:\.[^/]+)?\/files\/usr\/?$/));
+    const id = termux ? 'termux' : knownPlatforms.has(platform) ? platform : 'unknown';
+    const kernelRelease = input.release ?? release();
+    const nodeVersion = (input.nodeVersion ?? process.versions.node).replace(/^v/, '');
+    const arch = input.arch ?? process.arch;
+    const armVersion = input.armVersion !== undefined ? input.armVersion
+        : platform === process.platform && arch === process.arch ? Number(Reflect.get(process.config.variables, 'arm_version')) : null;
+    return {
+        id,
+        platform,
+        arch,
+        armVersion: arch === 'arm' && armVersion !== null && Number.isInteger(armVersion) && armVersion > 0 ? armVersion : null,
+        endianness: input.endianness ?? endianness(),
+        release: kernelRelease,
+        nodeVersion,
+        nodeMajor: Number.parseInt(nodeVersion, 10),
+        libc: platform === 'android' || termux ? 'bionic' : input.libc ?? (platform === 'linux' ? nativeLibc(platform) : 'none'),
+        isWsl: id === 'linux' && Boolean(env.WSL_INTEROP || env.WSL_DISTRO_NAME || /microsoft|wsl/i.test(kernelRelease)),
+        osRelease: input.osRelease ?? (platform === 'linux' && platform === process.platform ? readLinuxOsRelease() : '')
+    };
+}
+/** Selecting a native adapter does not establish that its service is running. */
+export function nativeAdapters(host = identifyPlatform()) {
+    const portable = { scheduler: null, inhibitor: null, volume: null, terminal: null, ipc: 'unix-socket', posixPermissions: true, airPlay: false };
+    if (host.id === 'darwin')
+        return { ...portable, scheduler: 'launchd', inhibitor: 'caffeinate', volume: 'macos', terminal: 'macos', airPlay: true };
+    if (host.id === 'win32')
+        return { ...portable, scheduler: 'task-scheduler', inhibitor: 'windows', volume: 'windows', terminal: 'windows', ipc: 'named-pipe', posixPermissions: false };
+    if (host.id === 'linux')
+        return { ...portable, scheduler: 'systemd', inhibitor: 'logind', volume: 'unix-audio', terminal: 'unix' };
+    if (['freebsd', 'openbsd', 'netbsd'].includes(host.id))
+        return { ...portable, terminal: 'unix' };
+    return portable;
+}
+export function readLinuxOsRelease(platform = process.platform) {
+    if (platform !== 'linux')
+        return '';
+    try {
+        return readFileSync('/etc/os-release', 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+let detectedLibc;
+function nativeLibc(platform) {
+    if (platform !== process.platform)
+        return 'unknown';
+    if (detectedLibc)
+        return detectedLibc;
+    try {
+        const report = process.report.getReport();
+        detectedLibc = report.header?.glibcVersionRuntime ? 'glibc'
+            : report.sharedObjects?.some(path => /(?:ld-musl|libc\.musl)/.test(path)) ? 'musl' : 'unknown';
+    }
+    catch {
+        detectedLibc = 'unknown';
+    }
+    return detectedLibc;
+}

package/dist/platform/shell.js

@@ -0,0 +1,24 @@
+/**
+ * Keep values out of PowerShell source when a native tool or script shim must
+ * run there. Native argument conversion still belongs to the target command;
+ * terminal launches use an encoded Node bootstrap for arbitrary argv values.
+ */
+export function powershellCommand(values, environment = {}, options = {}) {
+    if (!values[0])
+        throw new Error('A PowerShell command is required.');
+    if ([...values, ...Object.keys(environment), ...Object.values(environment)].some(value => value.includes('\0'))) {
+        throw new Error('PowerShell command values cannot contain NUL bytes.');
+    }
+    const payload = Buffer.from(JSON.stringify({ command: values[0], args: values.slice(1), environment }), 'utf8').toString('base64');
+    const script = [
+        "$ErrorActionPreference='Stop'",
+        "$ProgressPreference='SilentlyContinue'",
+        `$radiocliInvocation=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${payload}')) | ConvertFrom-Json`,
+        "foreach($radiocliVariable in $radiocliInvocation.environment.PSObject.Properties){[Environment]::SetEnvironmentVariable($radiocliVariable.Name,[string]$radiocliVariable.Value,'Process')}",
+        '$radiocliArguments=@($radiocliInvocation.args | ForEach-Object {[string]$_})',
+        '$global:LASTEXITCODE=0',
+        '& ([string]$radiocliInvocation.command) @radiocliArguments',
+        ...(options.keepOpen ? [] : ['$radiocliSucceeded=$?', 'if(-not $radiocliSucceeded -and $LASTEXITCODE -eq 0){exit 1}', 'exit $LASTEXITCODE'])
+    ].join(';');
+    return ['-NoLogo', '-NoProfile', ...(options.keepOpen ? ['-NoExit'] : ['-NonInteractive']), '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')];
+}

package/dist/platform/storage.js

@@ -0,0 +1,48 @@
+import { accessSync, constants, statSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+/** Access checks are advisory: ACLs, mounts, and permissions can change before a write. */
+export function storageReadiness(filePath) {
+    try {
+        assertStorageWritable(filePath);
+        return {
+            status: 'available',
+            message: 'Filesystem access checks passed for the library location; each operation still verifies its write.'
+        };
+    }
+    catch {
+        return {
+            status: 'unavailable',
+            message: 'The library location is not accessible for writes. Check permissions or set RADIOCLI_HOME to a private writable directory; existing readable data can still be inspected.'
+        };
+    }
+}
+/** Does not create a probe file or missing directories. The actual write remains authoritative. */
+export function assertStorageWritable(filePath) {
+    try {
+        if (!statSync(filePath).isFile()) {
+            throw Object.assign(new Error('The library destination is not a regular file.'), { code: 'EINVAL' });
+        }
+        // An atomic rename could otherwise replace a deliberately read-only file on POSIX.
+        accessSync(filePath, constants.R_OK | constants.W_OK);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    let parent = dirname(resolve(filePath));
+    while (true) {
+        try {
+            if (!statSync(parent).isDirectory()) {
+                throw Object.assign(new Error('The library parent is not a directory.'), { code: 'ENOTDIR' });
+            }
+            accessSync(parent, constants.W_OK | constants.X_OK);
+            return;
+        }
+        catch (error) {
+            const ancestor = dirname(parent);
+            if (error.code !== 'ENOENT' || ancestor === parent)
+                throw error;
+            parent = ancestor;
+        }
+    }
+}

package/dist/platform/support.js

@@ -0,0 +1,214 @@
+import { identifyPlatform } from './runtime.js';
+/**
+ * Runtime policy and project evidence are deliberately independent. Catalogs,
+ * platform mocks, containers, and downloaded artifacts never supply evidence.
+ * This checks the Node 22/24 reference matrix; other newer lines remain unverified.
+ * OS vendor lifecycle, CPU instruction levels, libc versions, and audio services
+ * require separate checks when the profile does not contain those facts.
+ *
+ * Reference policy (checked 2026-09-07):
+ * https://github.com/nodejs/node/blob/v22.x/BUILDING.md#platform-list
+ * https://github.com/nodejs/node/blob/v24.x/BUILDING.md#platform-list
+ */
+export function assessPlatformSupport(host = identifyPlatform(), suppliedEvidence = {}) {
+    const evidence = {
+        nativeRuntimeVerified: suppliedEvidence.nativeRuntimeVerified === true,
+        packedInstallVerified: suppliedEvidence.packedInstallVerified === true,
+        playbackVerified: suppliedEvidence.playbackVerified === true,
+        requiredCi: suppliedEvidence.requiredCi === true
+    };
+    const runtime = assessRuntime(host);
+    const reasons = [...runtime.reasons];
+    let tier = 'experimental';
+    if (runtime.status === 'unsupported') {
+        tier = 'unsupported';
+    }
+    else if (evidence.nativeRuntimeVerified && evidence.packedInstallVerified && evidence.playbackVerified) {
+        tier = evidence.requiredCi ? 'first-class' : 'supported';
+        reasons.push(evidence.requiredCi
+            ? 'Native runtime, packed installation, and playback are verified with required CI coverage.'
+            : 'Native runtime, packed installation, and playback are verified; required CI coverage is not established.');
+    }
+    else {
+        if (!evidence.nativeRuntimeVerified)
+            reasons.push('Native runtime execution has not been verified.');
+        if (!evidence.packedInstallVerified)
+            reasons.push('Packed npm installation has not been verified.');
+        if (!evidence.playbackVerified)
+            reasons.push('Playback has not been verified.');
+    }
+    return { tier, runtime, reasons, evidence };
+}
+function assessRuntime(host) {
+    const node = /^(\d+)\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.exec(host.nodeVersion);
+    if (!node)
+        return assessment('unverified', 'unverified', `Cannot assess the Node.js version ${JSON.stringify(host.nodeVersion)}.`);
+    const major = Number(node[1]);
+    if (!Number.isSafeInteger(major))
+        return assessment('unverified', 'unverified', 'The Node.js major version is not recognized.');
+    if (major < 22)
+        return assessment('unsupported', 'unsupported', `RadioCLI requires Node.js 22 or newer; this runtime is ${host.nodeVersion}.`);
+    if (major !== 22 && major !== 24) {
+        return assessment('unverified', 'unverified', `Node.js ${major} meets the package minimum, but its platform requirements are outside the verified Node.js 22/24 reference matrix.`);
+    }
+    const arch = host.arch === 'arm' && host.armVersion === 7 ? 'armv7' : architecture(host.arch);
+    if (host.id === 'darwin' && arch === 'ia32')
+        return assessment('unsupported', 'unsupported', 'Node.js 22/24 do not provide a 32-bit macOS runtime; use Intel x64 or Apple Silicon arm64.');
+    if (host.id === 'win32' && major === 24 && arch === 'ia32')
+        return assessment('unsupported', 'unsupported', 'Node.js 24 has no Windows x86 runtime; use Node.js 22 for ia32 or a native x64/arm64 runtime.');
+    if (host.id === 'aix' && (arch === 'ppc64' || arch === 'ppc64le') && (host.endianness !== 'BE' || arch === 'ppc64le')) {
+        return assessment('unsupported', 'unsupported', 'The AIX Node.js runtime requires big-endian ppc64; a little-endian POWER profile is incompatible.');
+    }
+    const version = releaseVersion(host.release);
+    if (!version) {
+        return assessment('unverified', 'unverified', `${host.id === 'darwin' ? 'Darwin' : host.platform} release is unavailable or unrecognized; runtime eligibility needs the OS version.`);
+    }
+    switch (host.id) {
+        case 'darwin':
+            if (!['x64', 'arm64'].includes(arch))
+                return unknownArchitecture(host);
+            // os.release() is the Darwin kernel: Darwin 20 = macOS 11,
+            // Darwin 22.6 = macOS 13.5. It is not a macOS product-version string.
+            if (version.length < 2)
+                return assessment('unverified', 'tier-1', 'A complete Darwin kernel release is needed to check the macOS runtime minimum.');
+            if (olderThan(version, major === 22 ? [20, 0] : [22, 6])) {
+                return assessment('unsupported', 'unsupported', `Node.js ${major} requires ${major === 22 ? 'macOS 11 (Darwin 20)' : 'macOS 13.5 (Darwin 22.6)'} or newer.`);
+            }
+            return assessment('eligible', 'tier-1', `The Darwin kernel meets the Node.js ${major} macOS binary minimum for ${arch}.`);
+        case 'win32':
+            if (!['x64', 'arm64', 'ia32'].includes(arch))
+                return unknownArchitecture(host);
+            if (version.length < 2)
+                return assessment('unverified', 'unverified', 'A complete Windows kernel version is needed to check the Windows 10 minimum.');
+            if (olderThan(version, [10, 0]))
+                return assessment('unsupported', 'unsupported', 'The standard Node.js 22/24 Windows runtime requires Windows 10 / Server 2016 or newer.');
+            return assessment('eligible', arch === 'arm64' ? 'tier-2' : 'tier-1', arch === 'ia32'
+                ? 'Node.js 22 provides Windows x86 binaries; upstream tests run under WoW64, which does not establish native 32-bit Windows verification.'
+                : `Node.js ${major} provides a Windows ${arch} runtime; the kernel version alone does not distinguish Windows desktop and Server editions.`);
+        case 'linux':
+            return linuxRuntime(host, arch, major, version);
+        case 'freebsd':
+            // Port allowlists are not evidence that every release/CPU binary exists.
+            // https://github.com/freebsd/freebsd-ports/blob/main/www/node22/Makefile
+            // https://github.com/freebsd/freebsd-ports/blob/main/www/node24/Makefile
+            if (!['x64', 'arm64', 'ia32', 'armv7', 'ppc64', 'ppc64le'].includes(arch))
+                return unknownArchitecture(host);
+            if (olderThan(version, [13, 2]))
+                return assessment('unverified', 'experimental', 'FreeBSD is below the upstream experimental 13.2 baseline; a compatible Node.js port needs separate verification.');
+            return assessment('eligible', arch === 'x64' ? 'experimental' : 'community', 'FreeBSD has Node.js 22/24 ports; use the matching npm-node package and verify availability for this release and architecture.');
+        case 'openbsd':
+            // https://github.com/openbsd/ports/blob/master/lang/node/Makefile
+            if (!['x64', 'arm64', 'ia32', 'ppc64', 'riscv64'].includes(arch))
+                return unknownArchitecture(host);
+            return assessment('eligible', 'community', 'OpenBSD uses its community Node.js port; the selected OS release and architecture must provide Node.js 22 or newer.');
+        case 'netbsd':
+            // https://github.com/NetBSD/pkgsrc/tree/trunk/lang/nodejs22
+            if (!['x64', 'arm64'].includes(arch))
+                return unknownArchitecture(host);
+            return assessment('eligible', 'community', 'NetBSD has pkgsrc Node.js 22/24 ports; binary packages are named nodejs and depend on the repository release and architecture.');
+        case 'termux':
+            // https://github.com/termux/termux-packages/blob/master/packages/nodejs-lts/build.sh
+            if (!['x64', 'arm64', 'ia32', 'arm', 'armv7'].includes(arch))
+                return unknownArchitecture(host);
+            return assessment('eligible', 'community', 'Termux needs its Android Bionic Node.js package and Android 7 or newer; the Linux kernel release does not establish the Android API version.');
+        case 'android':
+            return assessment('unverified', 'unverified', 'Android outside Termux has no established RadioCLI runtime installation route; verify a compatible Bionic Node.js build.');
+        case 'haiku':
+            // https://github.com/haikuports/haikuports/tree/master/net-libs/nodejs
+            return assessment('unverified', 'community', 'HaikuPorts currently provides Node.js 20; this newer runtime requires a separately verified custom Node.js port.');
+        case 'sunos':
+            return assessment('unverified', 'community', 'SmartOS x64 has upstream Tier 2 status; generic SunOS kernel 5.11 does not identify SmartOS, illumos distribution, or its version. Verify the selected Node.js port and playback backend.');
+        case 'aix':
+            if (arch !== 'ppc64')
+                return unknownArchitecture(host);
+            return assessment('eligible', 'tier-2', `AIX requires big-endian POWER8 or newer and AIX 7.2 TL04 or newer${major === 24 ? ', plus libstdc++12' : ''}; uname release alone does not establish these prerequisites. Playback backend availability needs separate verification.`);
+        case 'unknown':
+            return unknownArchitecture(host);
+    }
+}
+function linuxRuntime(host, arch, major, version) {
+    if (host.isWsl)
+        return assessment('unverified', 'community', 'WSL uses a Linux Node.js runtime, but upstream support requires reproducing issues on native Linux; verify this WSL environment separately.');
+    if (arch === 'arm')
+        return assessment('unverified', 'unverified', 'The generic arm architecture does not identify its ISA revision. Node.js 22 Tier 1 applies to ARMv7; older ARM and Node.js 24 ARMv7 need separate community verification.');
+    if ((arch === 'ppc64' || arch === 'ppc64le') && host.endianness !== 'LE') {
+        return assessment('unverified', 'unverified', 'Upstream Linux POWER support applies to ppc64le, not big-endian ppc64. A compatible big-endian Node.js 22+ community port must be verified separately.');
+    }
+    if (host.libc === 'musl') {
+        // Node 24 now publishes x64-musl files while its matrix remains Experimental.
+        // Other known routes are distributor builds, not glibc binary compatibility.
+        // https://nodejs.org/dist/latest-v24.x/SHASUMS256.txt
+        // https://github.com/nodejs/docker-node/blob/main/versions.json
+        const knownRoute = ['x64', 'arm64', 's390x'].includes(arch) || (arch === 'armv7' && major === 22);
+        if (!knownRoute)
+            return assessment('unverified', 'community', `A Node.js ${major} musl build for ${host.arch} requires separate package and runtime verification.`);
+        if (olderThan(version, [3, 10]))
+            return assessment('unverified', 'experimental', 'This kernel is below the Node.js musl reference baseline; compatibility is unverified.');
+        return assessment('eligible', arch === 'x64' ? 'experimental' : 'community', `Use a musl-specific Node.js ${major} build and its libstdc++ dependencies; libc family detection does not verify the musl version.`);
+    }
+    if (host.libc !== 'glibc')
+        return assessment('unverified', 'unverified', `Linux libc is ${host.libc}; select a compatible Node.js build before declaring runtime eligibility.`);
+    let upstream;
+    let minimumKernel = [4, 18];
+    let minimumGlibc = '2.28';
+    let detail = '';
+    if (arch === 'x64' || arch === 'arm64')
+        upstream = 'tier-1';
+    else if (arch === 'armv7') {
+        upstream = major === 22 ? 'tier-1' : 'experimental';
+        detail = major === 22 ? ' ARMv7 binaries also require GLIBCXX_3.4.28.' : ' Node.js 24 ARMv7 needs a community build; no upstream release binary is provided.';
+    }
+    else if (arch === 'ppc64' || arch === 'ppc64le' || arch === 's390x') {
+        upstream = 'tier-2';
+        if (arch !== 's390x')
+            detail = ' POWER8 or newer is required.';
+    }
+    else if (arch === 'riscv64' && major === 24) {
+        upstream = 'experimental';
+        minimumKernel = [5, 19];
+        minimumGlibc = '2.36';
+    }
+    else if (arch === 'ia32') {
+        upstream = 'experimental';
+        minimumKernel = [3, 10];
+        minimumGlibc = '2.17';
+    }
+    else
+        return unknownArchitecture(host);
+    if (version.length < 2 || olderThan(version, minimumKernel)) {
+        return assessment('unverified', upstream, `The glibc Linux kernel does not establish the ${minimumKernel.join('.')} reference minimum; older kernels may work but require separate verification.`);
+    }
+    return assessment('eligible', upstream, `Node.js ${major} requires glibc >= ${minimumGlibc} and a compatible libstdc++; the profile records only the libc family.${detail}`);
+}
+function assessment(status, upstream, ...reasons) {
+    return { status, upstream, reasons };
+}
+function unknownArchitecture(host) {
+    return assessment('unverified', 'unverified', `No runtime eligibility is established for ${host.platform}/${host.arch}; verify a compatible Node.js port instead of inferring support from another target.`);
+}
+function architecture(arch) {
+    if (['amd64', 'x86_64'].includes(arch))
+        return 'x64';
+    if (arch === 'aarch64')
+        return 'arm64';
+    if (['x86', 'i386', 'i686'].includes(arch))
+        return 'ia32';
+    if (arch === 'armv7l')
+        return 'armv7';
+    return arch;
+}
+function releaseVersion(release) {
+    const match = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:[.+_-][\w.+-]+)?$/.exec(release);
+    if (!match)
+        return null;
+    const parts = match.slice(1).filter(part => part !== undefined).map(Number);
+    return parts.every(Number.isSafeInteger) ? parts : null;
+}
+function olderThan(actual, minimum) {
+    for (let index = 0; index < minimum.length; index++) {
+        const difference = (actual[index] ?? 0) - minimum[index];
+        if (difference !== 0)
+            return difference < 0;
+    }
+    return false;
+}