Add native self-hosted instance connection to fluxer_desktop

Trimmed monorepo checkout (fluxer_desktop + packages/voice_engine_v2 +
tools/ci) with a "Connect to a Different Server" menu item and popout
that lets the desktop app switch to any self-hosted Fluxer instance,
plus fixes for well-known discovery on single-domain self-hosted
deployments and a false-positive ERR_ABORTED on same-origin client
redirects during the switch. Defaults to chat.fluxr.chat and uses an
isolated userData directory from the official build.

fluxer_desktop/native/linux-notifications/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "fluxer_linux_notifications"
+version = "0.0.0"
+edition = "2024"
+license = "AGPL-3.0-or-later"
+publish = false
+
+[workspace]
+resolver = "2"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+async-io = "2.6.0"
+futures-lite = "2.6.1"
+napi = {version = "3.9.1", default-features = false, features = ["dyn-symbols", "napi8"]}
+napi-derive = "3.5.6"
+zbus = "5.16.0"
+
+[build-dependencies]
+napi-build = "2.3.2"

fluxer_desktop/native/linux-notifications/build.rs

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+fn main() {
+    napi_build::setup();
+}

fluxer_desktop/native/linux-notifications/index.d.ts

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+export type Urgency = 'low' | 'normal' | 'critical';
+
+export interface NotifyImageData {
+	width: number;
+	height: number;
+	rowstride: number;
+	hasAlpha: boolean;
+	bitsPerSample: number;
+	channels: number;
+	data: Buffer | Uint8Array;
+}
+
+export interface NotifyAction {
+	key: string;
+	label: string;
+}
+
+export interface NotifyPayload {
+	appName: string;
+	replacesId?: number;
+	appIcon?: string;
+	summary: string;
+	body: string;
+	actions?: ReadonlyArray<NotifyAction>;
+	expireTimeoutMs?: number;
+	hints?: {
+		urgency?: Urgency;
+		category?: string;
+		desktopEntry?: string;
+		soundFile?: string;
+		transient?: boolean;
+		actionIcons?: boolean;
+		imageData?: NotifyImageData;
+	};
+}
+
+export type FreedesktopNotificationEvent =
+	| {kind: 'actionInvoked'; id: number; actionKey: string}
+	| {kind: 'closed'; id: number; reason: number};
+
+export interface ServerInformation {
+	name: string;
+	vendor: string;
+	version: string;
+	specVersion: string;
+}
+
+export declare class FreedesktopNotifications {
+	constructor(onEvent: (event: FreedesktopNotificationEvent) => void);
+
+	notify(payload: NotifyPayload): Promise<number>;
+
+	closeNotification(id: number): Promise<void>;
+
+	getServerCapabilities(): Promise<Array<string>>;
+
+	close(): Promise<void>;
+}
+
+export declare function getServerInformation(): Promise<ServerInformation>;
+
+export declare const loadError: Error | null;

fluxer_desktop/native/linux-notifications/index.js

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+const {existsSync} = require('node:fs');
+const {join, sep} = require('node:path');
+const {createNativeLoadError, loadNativeBinding} = require('./loader-diagnostics.cjs');
+const MODULE_NAME = '@fluxer/linux-notifications';
+const SKIP_NATIVE_PROBE_ENV = 'FLUXER_LINUX_NOTIFICATIONS_SKIP_NATIVE_PROBE';
+const REQUIRED_FREEDESKTOP_METHODS = ['notify', 'closeNotification', 'getServerCapabilities', 'close'];
+
+function resolveNativeRoot() {
+	const asarSegment = `${sep}app.asar${sep}`;
+	if (!__dirname.includes(asarSegment)) return __dirname;
+	const unpackedDir = __dirname.replace(asarSegment, `${sep}app.asar.unpacked${sep}`);
+	return existsSync(unpackedDir) ? unpackedDir : __dirname;
+}
+
+function nativeFileName() {
+	if (process.platform !== 'linux') {
+		throw new Error(`@fluxer/linux-notifications is only supported on Linux, got ${process.platform}`);
+	}
+	switch (process.arch) {
+		case 'x64':
+			return 'linux-notifications.linux-x64-gnu.node';
+		case 'arm64':
+			return 'linux-notifications.linux-arm64-gnu.node';
+		default:
+			throw new Error(`Unsupported Linux architecture: ${process.arch}`);
+	}
+}
+
+function ownPropertyNames(value) {
+	if ((typeof value !== 'object' && typeof value !== 'function') || value == null) return [];
+	return Object.getOwnPropertyNames(value).sort();
+}
+
+function bindingSurface(bindingValue) {
+	const freedesktopNotifications = bindingValue ? bindingValue.FreedesktopNotifications : null;
+	const prototype = freedesktopNotifications ? freedesktopNotifications.prototype : null;
+	return {
+		bindingKeys: ownPropertyNames(bindingValue),
+		freedesktopNotificationsType: typeof freedesktopNotifications,
+		freedesktopNotificationsName: freedesktopNotifications ? freedesktopNotifications.name : null,
+		freedesktopNotificationsPrototypeKeys: ownPropertyNames(prototype),
+		getServerInformationType: typeof (bindingValue ? bindingValue.getServerInformation : null),
+	};
+}
+
+function validateBindingSurface(bindingValue, nativeRoot, nativePath) {
+	const surface = bindingSurface(bindingValue);
+	const missing = [];
+	if (typeof bindingValue?.FreedesktopNotifications !== 'function') {
+		missing.push('FreedesktopNotifications constructor');
+	} else {
+		for (const method of REQUIRED_FREEDESKTOP_METHODS) {
+			if (typeof bindingValue.FreedesktopNotifications.prototype?.[method] !== 'function') {
+				missing.push(`FreedesktopNotifications.prototype.${method}`);
+			}
+		}
+	}
+	if (typeof bindingValue?.getServerInformation !== 'function') {
+		missing.push('getServerInformation');
+	}
+	if (missing.length === 0) return;
+	throw createNativeLoadError({
+		moduleName: MODULE_NAME,
+		nativePath,
+		nativeRoot,
+		packageDir: __dirname,
+		reason: `native binding surface mismatch: missing ${missing.join(', ')}`,
+		skipNativeProbeEnv: SKIP_NATIVE_PROBE_ENV,
+		extraDiagnostics: [{name: 'bindingSurface', text: JSON.stringify(surface, null, 2)}],
+	});
+}
+
+let binding = null;
+let loadError = null;
+
+if (process.platform === 'linux') {
+	try {
+		const nativeRoot = resolveNativeRoot();
+		const nativePath = join(nativeRoot, nativeFileName());
+		const loaded = loadNativeBinding({
+			moduleName: MODULE_NAME,
+			nativePath,
+			nativeRoot,
+			packageDir: __dirname,
+			skipNativeProbeEnv: SKIP_NATIVE_PROBE_ENV,
+		});
+		binding = loaded.binding;
+		loadError = loaded.loadError;
+		if (loadError) throw loadError;
+		validateBindingSurface(binding, nativeRoot, nativePath);
+	} catch (error) {
+		loadError = createNativeLoadError({
+			moduleName: MODULE_NAME,
+			nativeRoot: resolveNativeRoot(),
+			packageDir: __dirname,
+			reason: 'native loader threw before binding load completed',
+			cause: error,
+			skipNativeProbeEnv: SKIP_NATIVE_PROBE_ENV,
+		});
+		throw loadError;
+	}
+}
+
+module.exports = {
+	FreedesktopNotifications: binding ? binding.FreedesktopNotifications : null,
+	getServerInformation: binding ? binding.getServerInformation : null,
+	loadError,
+};

fluxer_desktop/native/linux-notifications/loader-diagnostics.cjs

@@ -0,0 +1,524 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+const {existsSync, readdirSync, readFileSync, statSync} = require('node:fs');
+const os = require('node:os');
+const {basename} = require('node:path');
+const {spawnSync} = require('node:child_process');
+const NATIVE_LOAD_ERROR_MARKER = Symbol.for('fluxer.nativeLoadError');
+const MAX_TEXT_LENGTH = 6000;
+const MAX_DIRECTORY_ENTRIES = 80;
+
+function trimText(value, limit = MAX_TEXT_LENGTH) {
+	const text = Buffer.isBuffer(value) ? value.toString('utf8') : String(value ?? '');
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	return trimmed.length > limit ? `${trimmed.slice(0, limit)}\n...<truncated>` : trimmed;
+}
+
+function errorDiagnostic(error) {
+	if (!error) return null;
+	if (error instanceof Error) {
+		return {
+			name: error.name || 'Error',
+			message: error.message,
+			code: error.code || null,
+			stack: trimText(error.stack || error.message),
+		};
+	}
+	return {
+		name: typeof error,
+		message: trimText(String(error)),
+		code: null,
+		stack: null,
+	};
+}
+
+function formatErrorDiagnostic(diagnostic) {
+	if (!diagnostic) return null;
+	const lines = [];
+	if (diagnostic.code) lines.push(`code=${diagnostic.code}`);
+	if (diagnostic.stack) lines.push(diagnostic.stack);
+	else if (diagnostic.message) lines.push(diagnostic.message);
+	return trimText(lines.join('\n'));
+}
+
+function fileDiagnostic(filePath) {
+	if (!filePath) return {path: null, exists: false, error: 'not resolved'};
+	try {
+		const stat = statSync(filePath);
+		return {
+			path: filePath,
+			exists: true,
+			size: stat.size,
+			mode: `0${(stat.mode & 0o777).toString(8)}`,
+			mtime: stat.mtime.toISOString(),
+			isFile: stat.isFile(),
+			isDirectory: stat.isDirectory(),
+		};
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return {path: filePath, exists: false, error: reason};
+	}
+}
+
+function formatFileDiagnostic(diagnostic) {
+	if (!diagnostic) return 'not resolved';
+	if (!diagnostic.exists) return `exists=false, statError=${diagnostic.error || '<unknown>'}`;
+	return [
+		`exists=true`,
+		`size=${diagnostic.size}`,
+		`mode=${diagnostic.mode}`,
+		`mtime=${diagnostic.mtime}`,
+		`isFile=${diagnostic.isFile}`,
+	].join(', ');
+}
+
+function directoryDiagnostic(dirPath) {
+	if (!dirPath) return {path: null, ok: false, error: 'not resolved', entries: [], total: 0, omitted: 0};
+	try {
+		const entries = readdirSync(dirPath, {withFileTypes: true}).map((entry) => ({
+			name: entry.name,
+			type: entry.isDirectory() ? 'directory' : entry.isFile() ? 'file' : 'other',
+		}));
+		entries.sort((a, b) => a.name.localeCompare(b.name));
+		const visible = entries.slice(0, MAX_DIRECTORY_ENTRIES);
+		return {
+			path: dirPath,
+			ok: true,
+			entries: visible,
+			total: entries.length,
+			omitted: Math.max(0, entries.length - visible.length),
+		};
+	} catch (error) {
+		return {
+			path: dirPath,
+			ok: false,
+			error: error instanceof Error ? error.message : String(error),
+			entries: [],
+			total: 0,
+			omitted: 0,
+		};
+	}
+}
+
+function formatDirectoryDiagnostic(diagnostic) {
+	if (!diagnostic) return '<unavailable>';
+	if (!diagnostic.ok) return `directory listing failed: ${diagnostic.error || '<unknown>'}`;
+	const entries = diagnostic.entries.map((entry) => `${entry.name}${entry.type === 'directory' ? '/' : ''}`);
+	const suffix = diagnostic.omitted > 0 ? [`...<${diagnostic.omitted} more entries>`] : [];
+	return [...entries, ...suffix].join('\n') || '<empty>';
+}
+
+function selectedEnvironmentNames(skipNativeProbeEnv) {
+	const names = [
+		'ELECTRON_RUN_AS_NODE',
+		'FLUXER_NATIVE_MODULE_PREFLIGHT_CHILD',
+		'LD_LIBRARY_PATH',
+		'DYLD_LIBRARY_PATH',
+		'DISPLAY',
+		'WAYLAND_DISPLAY',
+		'XDG_CURRENT_DESKTOP',
+		'XDG_SESSION_TYPE',
+		'DBUS_SESSION_BUS_ADDRESS',
+		'PULSE_SERVER',
+		'PIPEWIRE_REMOTE',
+		'PATH',
+	];
+	if (skipNativeProbeEnv) names.push(skipNativeProbeEnv);
+	return names;
+}
+
+function environmentDiagnostics(skipNativeProbeEnv) {
+	return Object.fromEntries(
+		selectedEnvironmentNames(skipNativeProbeEnv).map((name) => [name, process.env[name] ?? null]),
+	);
+}
+
+function formatEnvironment(diagnostic) {
+	return Object.entries(diagnostic)
+		.map(([name, value]) => `${name}=${value ?? '<unset>'}`)
+		.join('\n');
+}
+
+function runtimeDiagnostics() {
+	const versions = process.versions || {};
+	let reportHeader = null;
+	if (process.report && typeof process.report.getReport === 'function') {
+		try {
+			reportHeader = process.report.getReport().header || null;
+		} catch {
+			reportHeader = null;
+		}
+	}
+	const glibcRuntime = versions.glibcVersionRuntime || reportHeader?.glibcVersionRuntime || '<unknown>';
+	const glibcCompiler = versions.glibcVersionCompiler || reportHeader?.glibcVersionCompiler || '<unknown>';
+	return {
+		node: versions.node || null,
+		electron: versions.electron || null,
+		modules: versions.modules || null,
+		napi: versions.napi || null,
+		v8: versions.v8 || null,
+		uv: versions.uv || null,
+		openssl: versions.openssl || null,
+		glibcRuntime,
+		glibcCompiler,
+		platform: process.platform,
+		arch: process.arch,
+		osType: os.type(),
+		osRelease: os.release(),
+		osVersion: typeof os.version === 'function' ? os.version() : null,
+		execPath: process.execPath,
+		resourcesPath: process.resourcesPath || null,
+		cwd: process.cwd(),
+	};
+}
+
+function formatRuntimeDiagnostics(diagnostic) {
+	return [
+		`node=${diagnostic.node || '<unknown>'}`,
+		`electron=${diagnostic.electron || '<none>'}`,
+		`modules=${diagnostic.modules || '<unknown>'}`,
+		`napi=${diagnostic.napi || '<unknown>'}`,
+		`v8=${diagnostic.v8 || '<unknown>'}`,
+		`uv=${diagnostic.uv || '<unknown>'}`,
+		`openssl=${diagnostic.openssl || '<unknown>'}`,
+		`glibcRuntime=${diagnostic.glibcRuntime || '<unknown>'}`,
+		`glibcCompiler=${diagnostic.glibcCompiler || '<unknown>'}`,
+		`process=${diagnostic.platform}/${diagnostic.arch}`,
+		`os=${diagnostic.osType} ${diagnostic.osRelease} ${diagnostic.osVersion || '<unknown>'}`,
+		`execPath=${diagnostic.execPath}`,
+		`resourcesPath=${diagnostic.resourcesPath || '<unknown>'}`,
+		`cwd=${diagnostic.cwd}`,
+	].join('\n');
+}
+
+const REDISTRIBUTABLE_RUNTIME_PATTERNS = [
+	/^vcruntime\d+(?:_\d+)?\.dll$/i,
+	/^msvcp\d+(?:_\d+)?\.dll$/i,
+	/^msvcr\d+(?:_\d+)?\.dll$/i,
+	/^concrt\d+\.dll$/i,
+	/^vcamp\d+\.dll$/i,
+	/^vcomp\d+\.dll$/i,
+];
+
+function readPeImports(filePath) {
+	let buffer;
+	try {
+		buffer = readFileSync(filePath);
+	} catch {
+		return null;
+	}
+	if (buffer.length < 0x40) return null;
+	const peOffset = buffer.readUInt32LE(0x3c);
+	if (peOffset <= 0 || peOffset + 24 >= buffer.length) return null;
+	if (buffer.readUInt32LE(peOffset) !== 0x4550) return null;
+	const coffOffset = peOffset + 4;
+	const numberOfSections = buffer.readUInt16LE(coffOffset + 2);
+	const sizeOfOptionalHeader = buffer.readUInt16LE(coffOffset + 16);
+	const optionalHeaderOffset = coffOffset + 20;
+	if (optionalHeaderOffset + sizeOfOptionalHeader > buffer.length) return null;
+	const magic = buffer.readUInt16LE(optionalHeaderOffset);
+	if (magic !== 0x10b && magic !== 0x20b) return null;
+	const dataDirectoriesOffset = optionalHeaderOffset + (magic === 0x20b ? 112 : 96);
+	const importEntryOffset = dataDirectoriesOffset + 8;
+	if (importEntryOffset + 8 > buffer.length) return null;
+	const importRva = buffer.readUInt32LE(importEntryOffset);
+	if (importRva === 0) return [];
+	const sections = [];
+	const sectionTableOffset = optionalHeaderOffset + sizeOfOptionalHeader;
+	for (let i = 0; i < numberOfSections; i++) {
+		const base = sectionTableOffset + i * 40;
+		if (base + 40 > buffer.length) return null;
+		sections.push({
+			virtualSize: buffer.readUInt32LE(base + 8),
+			virtualAddress: buffer.readUInt32LE(base + 12),
+			rawSize: buffer.readUInt32LE(base + 16),
+			rawPointer: buffer.readUInt32LE(base + 20),
+		});
+	}
+	const rvaToOffset = (rva) => {
+		for (const s of sections) {
+			const span = Math.max(s.virtualSize, s.rawSize);
+			if (rva >= s.virtualAddress && rva < s.virtualAddress + span) {
+				return rva - s.virtualAddress + s.rawPointer;
+			}
+		}
+		return -1;
+	};
+	const readCString = (offset) => {
+		let end = offset;
+		while (end < buffer.length && buffer[end] !== 0) end++;
+		return buffer.toString('ascii', offset, end);
+	};
+	const importTableOffset = rvaToOffset(importRva);
+	if (importTableOffset < 0) return [];
+	const imports = new Set();
+	for (let i = 0; i < 1024; i++) {
+		const base = importTableOffset + i * 20;
+		if (base + 20 > buffer.length) break;
+		const lookupRva = buffer.readUInt32LE(base);
+		const nameRva = buffer.readUInt32LE(base + 12);
+		const iatRva = buffer.readUInt32LE(base + 16);
+		if (lookupRva === 0 && nameRva === 0 && iatRva === 0) break;
+		const nameOffset = rvaToOffset(nameRva);
+		if (nameOffset < 0) continue;
+		const name = readCString(nameOffset);
+		if (name) imports.add(name);
+	}
+	return Array.from(imports);
+}
+
+function windowsImportProbe(nativePath) {
+	const imports = readPeImports(nativePath);
+	if (imports === null) return null;
+	const sortedImports = [...imports].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+	const redistributable = sortedImports.filter((dll) =>
+		REDISTRIBUTABLE_RUNTIME_PATTERNS.some((pattern) => pattern.test(dll)),
+	);
+	return {
+		command: ['pe-imports', nativePath],
+		status: 0,
+		signal: null,
+		error: null,
+		stdout: sortedImports.join('\n') || null,
+		stderr: null,
+		missing: [],
+		redistributable,
+	};
+}
+
+function dependencyProbe(nativePath) {
+	if (!nativePath || !existsSync(nativePath)) return null;
+	if (process.platform === 'win32') return windowsImportProbe(nativePath);
+	const command =
+		process.platform === 'linux'
+			? ['ldd', nativePath]
+			: process.platform === 'darwin'
+				? ['otool', '-L', nativePath]
+				: null;
+	if (!command) return null;
+	const [bin, ...args] = command;
+	const result = spawnSync(bin, args, {
+		encoding: 'utf8',
+		timeout: 4000,
+		stdio: ['ignore', 'pipe', 'pipe'],
+	});
+	const stdout = trimText(result.stdout);
+	const stderr = trimText(result.stderr);
+	const missing =
+		process.platform === 'linux' && stdout
+			? stdout
+					.split('\n')
+					.map((line) => line.trim())
+					.filter((line) => line.includes('not found'))
+			: [];
+	return {
+		command,
+		status: result.status,
+		signal: result.signal || null,
+		error: result.error ? result.error.message : null,
+		stdout,
+		stderr,
+		missing,
+		redistributable: [],
+	};
+}
+
+function formatDependencyProbe(diagnostic) {
+	if (!diagnostic) return null;
+	const status = diagnostic.error
+		? `error=${diagnostic.error}`
+		: diagnostic.signal
+			? `signal=${diagnostic.signal}`
+			: `status=${diagnostic.status}`;
+	return [
+		`$ ${diagnostic.command.join(' ')}`,
+		status,
+		diagnostic.missing?.length ? `missing:\n${diagnostic.missing.join('\n')}` : null,
+		diagnostic.redistributable?.length
+			? `redistributableRuntimeImports (require VC++ redist on host):\n${diagnostic.redistributable.join('\n')}`
+			: null,
+		diagnostic.stdout ? `stdout:\n${diagnostic.stdout}` : null,
+		diagnostic.stderr ? `stderr:\n${diagnostic.stderr}` : null,
+	]
+		.filter(Boolean)
+		.join('\n');
+}
+
+function formatExtraDiagnostic(diagnostic) {
+	if (!diagnostic) return null;
+	if (typeof diagnostic === 'string') return diagnostic;
+	if (typeof diagnostic === 'object' && diagnostic.name && diagnostic.text) {
+		return `${diagnostic.name}:\n${diagnostic.text}`;
+	}
+	return `extra:\n${trimText(JSON.stringify(diagnostic, null, 2))}`;
+}
+
+function collectNativeDiagnostics({
+	moduleName,
+	nativePath,
+	nativeRoot,
+	packageDir,
+	reason,
+	cause,
+	skipNativeProbeEnv,
+	extraDiagnostics = [],
+}) {
+	return {
+		schemaVersion: 1,
+		moduleName,
+		reason,
+		target: {
+			platform: process.platform,
+			arch: process.arch,
+		},
+		packageDir: packageDir || null,
+		nativeRoot: nativeRoot || null,
+		nativePath: nativePath || null,
+		nativeFile: nativePath ? basename(nativePath) : null,
+		nativeFileStat: fileDiagnostic(nativePath),
+		runtime: runtimeDiagnostics(),
+		environment: environmentDiagnostics(skipNativeProbeEnv),
+		nativeRootEntries: directoryDiagnostic(nativeRoot),
+		dependencyProbe: dependencyProbe(nativePath),
+		extraDiagnostics: extraDiagnostics.filter(Boolean),
+		cause: errorDiagnostic(cause),
+	};
+}
+
+function formatNativeDiagnostics(diagnostics) {
+	const sections = [
+		`module=${diagnostics.moduleName}`,
+		`reason=${diagnostics.reason}`,
+		`target=${diagnostics.target.platform}/${diagnostics.target.arch}`,
+		`packageDir=${diagnostics.packageDir || '<unknown>'}`,
+		`nativeRoot=${diagnostics.nativeRoot || '<unknown>'}`,
+		`nativePath=${diagnostics.nativePath || '<unknown>'}`,
+		`nativeFile=${diagnostics.nativeFile || '<unknown>'}`,
+		`nativeFileStat=${formatFileDiagnostic(diagnostics.nativeFileStat)}`,
+		`runtime:\n${formatRuntimeDiagnostics(diagnostics.runtime)}`,
+		`environment:\n${formatEnvironment(diagnostics.environment)}`,
+		`nativeRootEntries:\n${formatDirectoryDiagnostic(diagnostics.nativeRootEntries)}`,
+		...diagnostics.extraDiagnostics.map(formatExtraDiagnostic).filter(Boolean),
+	];
+	const dependencyOutput = formatDependencyProbe(diagnostics.dependencyProbe);
+	if (dependencyOutput) sections.push(`dependencyProbe:\n${dependencyOutput}`);
+	const causeText = formatErrorDiagnostic(diagnostics.cause);
+	if (causeText) sections.push(`cause:\n${causeText}`);
+	return sections.join('\n');
+}
+
+function isNativeLoadError(error) {
+	return Boolean(error?.[NATIVE_LOAD_ERROR_MARKER]);
+}
+
+function createNativeLoadError({
+	moduleName,
+	nativePath,
+	nativeRoot,
+	packageDir,
+	reason,
+	cause,
+	skipNativeProbeEnv,
+	extraDiagnostics = [],
+}) {
+	if (isNativeLoadError(cause)) return cause;
+	const diagnostics = collectNativeDiagnostics({
+		moduleName,
+		nativePath,
+		nativeRoot,
+		packageDir,
+		reason,
+		cause,
+		skipNativeProbeEnv,
+		extraDiagnostics,
+	});
+	const error = new Error(`${moduleName} native module failed to load.\n${formatNativeDiagnostics(diagnostics)}`);
+	error.name = 'NativeModuleLoadError';
+	error[NATIVE_LOAD_ERROR_MARKER] = true;
+	error.nativeDiagnostics = diagnostics;
+	error.toJSON = () => ({
+		name: error.name,
+		message: error.message,
+		nativeDiagnostics: diagnostics,
+	});
+	if (cause) error.cause = cause;
+	return error;
+}
+
+function probeNativeBinary({moduleName, nativePath, nativeRoot, packageDir, skipNativeProbeEnv, timeoutMs = 5000}) {
+	if (!skipNativeProbeEnv || process.env[skipNativeProbeEnv] === '1') {
+		return null;
+	}
+	const result = spawnSync(process.execPath, ['-e', 'require(process.argv[1])', nativePath], {
+		env: {...process.env, ELECTRON_RUN_AS_NODE: '1', [skipNativeProbeEnv]: '1'},
+		encoding: 'utf8',
+		stdio: ['ignore', 'pipe', 'pipe'],
+		timeout: timeoutMs,
+	});
+	if (result.status === 0) return null;
+	const reason = result.error
+		? result.error.message
+		: result.signal
+			? `safety probe terminated by signal ${result.signal}`
+			: `safety probe exited with code ${result.status}`;
+	return createNativeLoadError({
+		moduleName,
+		nativePath,
+		nativeRoot,
+		packageDir,
+		reason,
+		skipNativeProbeEnv,
+		extraDiagnostics: [
+			result.stdout ? {name: 'probeStdout', text: trimText(result.stdout)} : null,
+			result.stderr ? {name: 'probeStderr', text: trimText(result.stderr)} : null,
+		],
+	});
+}
+
+function loadNativeBinding({moduleName, nativePath, nativeRoot, packageDir, skipNativeProbeEnv, probe = true}) {
+	if (!existsSync(nativePath)) {
+		return {
+			binding: null,
+			loadError: createNativeLoadError({
+				moduleName,
+				nativePath,
+				nativeRoot,
+				packageDir,
+				reason: 'native binary not found',
+				skipNativeProbeEnv,
+			}),
+		};
+	}
+	const nativeProbeError = probe
+		? probeNativeBinary({moduleName, nativePath, nativeRoot, packageDir, skipNativeProbeEnv})
+		: null;
+	if (nativeProbeError) {
+		return {binding: null, loadError: nativeProbeError};
+	}
+	try {
+		return {binding: require(nativePath), loadError: null};
+	} catch (error) {
+		return {
+			binding: null,
+			loadError: createNativeLoadError({
+				moduleName,
+				nativePath,
+				nativeRoot,
+				packageDir,
+				reason: 'require(nativePath) threw',
+				cause: error,
+				skipNativeProbeEnv,
+			}),
+		};
+	}
+}
+
+module.exports = {
+	collectNativeDiagnostics,
+	createNativeLoadError,
+	formatNativeDiagnostics,
+	isNativeLoadError,
+	loadNativeBinding,
+	probeNativeBinary,
+};

fluxer_desktop/native/linux-notifications/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@fluxer/linux-notifications",
+	"version": "0.0.0",
+	"description": "",
+	"private": true,
+	"license": "AGPL-3.0-or-later",
+	"os": [
+		"linux"
+	],
+	"cpu": [
+		"x64",
+		"arm64"
+	],
+	"main": "index.js",
+	"types": "index.d.ts",
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"loader-diagnostics.cjs",
+		"linux-notifications.linux-x64-gnu.node",
+		"linux-notifications.linux-arm64-gnu.node"
+	],
+	"scripts": {
+		"build": "cargo run --locked --quiet --manifest-path ../../../tools/ci/Cargo.toml -- build-desktop-native-addon",
+		"test": "cargo test --manifest-path Cargo.toml"
+	}
+}