@noxsoft/anima 2.0.3 → 2.0.4

package/dist/dist-CqDI82ei.js

@@ -0,0 +1,929 @@
+import { EventEmitter } from "events";
+import { execFile, spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import * as os from "os";
+import * as crypto from "crypto";
+
+//#region node_modules/.pnpm/file+..+svrn-node_typescript@5.9.3_zod@4.3.6/node_modules/@noxsoft/svrn-node/dist/index.js
+var ALL_TASK_TYPES = [
+	"ping",
+	"relay",
+	"compute",
+	"store",
+	"validate"
+];
+var DEFAULT_CONFIG = {
+	enabled: true,
+	dataDir: getDefaultDataDir(),
+	coordinatorUrl: "https://svrn.noxsoft.net",
+	resources: {
+		maxCpuPercent: 50,
+		maxRamMB: 512,
+		maxBandwidthMbps: 10,
+		maxDiskGB: 5
+	},
+	taskTypes: [...ALL_TASK_TYPES],
+	autoUpdate: {
+		enabled: true,
+		checkIntervalHours: 6,
+		autoRestart: true,
+		channel: "stable"
+	},
+	heartbeatIntervalSec: 30,
+	showEarnings: true
+};
+function getDefaultDataDir() {
+	return `${process.env["HOME"] || process.env["USERPROFILE"] || "/tmp"}/.svrn-node`;
+}
+function resolveConfig(partial) {
+	if (!partial) return { ...DEFAULT_CONFIG };
+	return {
+		...DEFAULT_CONFIG,
+		...partial,
+		resources: {
+			...DEFAULT_CONFIG.resources,
+			...partial.resources ?? {}
+		},
+		autoUpdate: {
+			...DEFAULT_CONFIG.autoUpdate,
+			...partial.autoUpdate ?? {}
+		},
+		taskTypes: partial.taskTypes ?? [...ALL_TASK_TYPES]
+	};
+}
+var PACKAGE_NAME = "@noxsoft/svrn-node";
+var REGISTRY_BASE = "https://registry.npmjs.org";
+var AutoUpdater = class extends EventEmitter {
+	config;
+	currentVersion;
+	checkTimer = null;
+	logFile;
+	checking = false;
+	constructor(config, dataDir) {
+		super();
+		this.config = config;
+		this.currentVersion = this.readCurrentVersion();
+		this.logFile = path.join(dataDir, "updates.log");
+		fs.mkdirSync(dataDir, { recursive: true });
+	}
+	/** Start the periodic update check loop. */
+	start() {
+		if (!this.config.enabled) return;
+		this.check();
+		const intervalMs = this.config.checkIntervalHours * 60 * 60 * 1e3;
+		this.checkTimer = setInterval(() => void this.check(), intervalMs);
+	}
+	/** Stop the update check loop. */
+	stop() {
+		if (this.checkTimer) {
+			clearInterval(this.checkTimer);
+			this.checkTimer = null;
+		}
+	}
+	/** Get the current installed version. */
+	getVersion() {
+		return this.currentVersion;
+	}
+	/** Manually trigger an update check. Returns info if update found, null otherwise. */
+	async check() {
+		if (this.checking) return null;
+		this.checking = true;
+		try {
+			const tag = this.config.channel === "beta" ? "beta" : "latest";
+			const latestVersion = await this.fetchLatestVersion(tag);
+			if (!latestVersion) return null;
+			if (this.isNewer(latestVersion, this.currentVersion)) {
+				const info = {
+					currentVersion: this.currentVersion,
+					latestVersion,
+					channel: this.config.channel,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString()
+				};
+				this.emit("update-available", info);
+				this.log(`Update available: ${this.currentVersion} -> ${latestVersion}`);
+				if (this.config.autoRestart) {
+					await this.installUpdate(latestVersion);
+					this.log(`Update installed: ${latestVersion}`);
+					this.emit("update-installed", info);
+					this.restartProcess();
+				}
+				return info;
+			}
+			return null;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			this.log(`Update check failed: ${msg}`);
+			this.emit("update-error", error);
+			return null;
+		} finally {
+			this.checking = false;
+		}
+	}
+	/**
+	* Install a specific version and restart (for manual `svrn-node update`).
+	* Returns the UpdateInfo if an update was installed, null if already current.
+	*/
+	async installAndRestart() {
+		const tag = this.config.channel === "beta" ? "beta" : "latest";
+		const latestVersion = await this.fetchLatestVersion(tag);
+		if (!latestVersion) {
+			this.log("No version found on npm — package may not be published yet.");
+			return null;
+		}
+		if (!this.isNewer(latestVersion, this.currentVersion)) return null;
+		const info = {
+			currentVersion: this.currentVersion,
+			latestVersion,
+			channel: this.config.channel,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.installUpdate(latestVersion);
+		this.log(`Update installed: ${latestVersion}`);
+		this.emit("update-installed", info);
+		return info;
+	}
+	/**
+	* Fetch the latest version from the npm registry HTTP API.
+	* Uses simple fetch — no npm CLI needed for checking.
+	*
+	* For the 'stable' channel, fetches the 'latest' dist-tag.
+	* For the 'beta' channel, fetches the 'beta' dist-tag.
+	*/
+	async fetchLatestVersion(tag) {
+		try {
+			const url = `${REGISTRY_BASE}/${encodeURIComponent(PACKAGE_NAME)}/${tag}`;
+			const response = await fetch(url, {
+				headers: { Accept: "application/json" },
+				signal: AbortSignal.timeout(15e3)
+			});
+			if (!response.ok) {
+				if (response.status === 404) return null;
+				return null;
+			}
+			return (await response.json()).version ?? null;
+		} catch {
+			return null;
+		}
+	}
+	/** Install the specified version via npm. */
+	installUpdate(version) {
+		return new Promise((resolve, reject) => {
+			const thisDir = path.dirname(fileURLToPath(import.meta.url));
+			const isGlobal = thisDir.includes("/lib/node_modules/") || thisDir.includes("\\node_modules\\");
+			execFile("npm", isGlobal ? [
+				"install",
+				"-g",
+				`${PACKAGE_NAME}@${version}`
+			] : ["install", `${PACKAGE_NAME}@${version}`], {
+				timeout: 12e4,
+				cwd: isGlobal ? void 0 : this.findProjectRoot(thisDir) ?? void 0
+			}, (error) => {
+				if (error) {
+					reject(/* @__PURE__ */ new Error(`Failed to install update: ${error.message}`));
+					return;
+				}
+				resolve();
+			});
+		});
+	}
+	/**
+	* Restart the process by exec-ing the svrn-node binary.
+	* This replaces the current process entirely with the new version.
+	*/
+	restartProcess() {
+		this.log("Restarting with updated binary...");
+		if (!process.argv[1]) {
+			this.log("Cannot determine binary path for restart — manual restart required.");
+			return;
+		}
+		const args = process.argv.slice(1);
+		try {
+			spawn(process.execPath, args, {
+				detached: true,
+				stdio: "inherit"
+			}).unref();
+			process.exit(0);
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			this.log(`Restart failed: ${msg} \u2014 manual restart required.`);
+		}
+	}
+	/** Read the current package version from package.json. */
+	readCurrentVersion() {
+		try {
+			let dir = path.dirname(fileURLToPath(import.meta.url));
+			for (let i = 0; i < 5; i++) {
+				const pkgPath = path.join(dir, "package.json");
+				if (fs.existsSync(pkgPath)) {
+					const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+					if (pkg.name === PACKAGE_NAME) return pkg.version ?? "0.0.0";
+				}
+				dir = path.dirname(dir);
+			}
+		} catch {}
+		return "0.0.0";
+	}
+	/** Compare semver strings. Returns true if `a` is newer than `b`. */
+	isNewer(a, b) {
+		const parse = (v) => v.replace(/[^0-9.]/g, "").split(".").map(Number);
+		const [aMajor = 0, aMinor = 0, aPatch = 0] = parse(a);
+		const [bMajor = 0, bMinor = 0, bPatch = 0] = parse(b);
+		if (aMajor !== bMajor) return aMajor > bMajor;
+		if (aMinor !== bMinor) return aMinor > bMinor;
+		return aPatch > bPatch;
+	}
+	/** Find the nearest ancestor directory containing package.json. */
+	findProjectRoot(startDir) {
+		let dir = startDir;
+		for (let i = 0; i < 10; i++) {
+			const pkgPath = path.join(dir, "package.json");
+			if (fs.existsSync(pkgPath)) {
+				if (JSON.parse(fs.readFileSync(pkgPath, "utf-8")).name !== PACKAGE_NAME) return dir;
+			}
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+		return null;
+	}
+	/** Append a log entry to the updates log file. */
+	log(message) {
+		const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+		try {
+			fs.appendFileSync(this.logFile, line);
+		} catch {}
+	}
+};
+var UCU_TO_USD = .001;
+var EarningsTracker = class {
+	ledgerFile;
+	sessionStart;
+	sessionEarnings = 0;
+	sessionTasks = 0;
+	allTimeEarnings = 0;
+	allTimeTasks = 0;
+	todayEarnings = 0;
+	todayTasks = 0;
+	todayDate;
+	constructor(dataDir) {
+		this.ledgerFile = path.join(dataDir, "earnings-ledger.jsonl");
+		this.sessionStart = (/* @__PURE__ */ new Date()).toISOString();
+		this.todayDate = this.utcDateString();
+		fs.mkdirSync(dataDir, { recursive: true });
+		this.loadHistorical();
+	}
+	/** Record earnings for a completed task. */
+	record(taskType, taskId, amount, durationMs) {
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			taskType,
+			taskId,
+			amount,
+			duration: durationMs
+		};
+		this.sessionEarnings += amount;
+		this.sessionTasks += 1;
+		this.allTimeEarnings += amount;
+		this.allTimeTasks += 1;
+		const today = this.utcDateString();
+		if (today !== this.todayDate) {
+			this.todayEarnings = 0;
+			this.todayTasks = 0;
+			this.todayDate = today;
+		}
+		this.todayEarnings += amount;
+		this.todayTasks += 1;
+		try {
+			fs.appendFileSync(this.ledgerFile, JSON.stringify(entry) + "\n");
+		} catch {}
+	}
+	/** Get a summary of earnings. */
+	getSummary() {
+		const today = this.utcDateString();
+		if (today !== this.todayDate) {
+			this.todayEarnings = 0;
+			this.todayTasks = 0;
+			this.todayDate = today;
+		}
+		const hoursToday = this.hoursSinceSessionStart();
+		const hourlyRate = hoursToday > 0 ? this.sessionEarnings / hoursToday : 0;
+		const estimatedMonthlyUCU = hourlyRate * 24 * 30;
+		const estimatedAnnualUCU = hourlyRate * 24 * 365;
+		return {
+			session: round(this.sessionEarnings),
+			today: round(this.todayEarnings),
+			allTime: round(this.allTimeEarnings),
+			tasksThisSession: this.sessionTasks,
+			tasksToday: this.todayTasks,
+			tasksAllTime: this.allTimeTasks,
+			estimatedMonthlySavingsUSD: round(estimatedMonthlyUCU * UCU_TO_USD),
+			estimatedAnnualSavingsUSD: round(estimatedAnnualUCU * UCU_TO_USD)
+		};
+	}
+	/** Get raw ledger entries for a date range. */
+	getLedger(fromDate, toDate) {
+		if (!fs.existsSync(this.ledgerFile)) return [];
+		const lines = fs.readFileSync(this.ledgerFile, "utf-8").trim().split("\n");
+		const entries = [];
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			try {
+				const entry = JSON.parse(line);
+				if (fromDate && entry.timestamp < fromDate) continue;
+				if (toDate && entry.timestamp > toDate) continue;
+				entries.push(entry);
+			} catch {}
+		}
+		return entries;
+	}
+	loadHistorical() {
+		if (!fs.existsSync(this.ledgerFile)) return;
+		const today = this.utcDateString();
+		const lines = fs.readFileSync(this.ledgerFile, "utf-8").trim().split("\n");
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			try {
+				const entry = JSON.parse(line);
+				this.allTimeEarnings += entry.amount;
+				this.allTimeTasks += 1;
+				if (entry.timestamp.startsWith(today)) {
+					this.todayEarnings += entry.amount;
+					this.todayTasks += 1;
+				}
+			} catch {}
+		}
+	}
+	utcDateString() {
+		return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	}
+	hoursSinceSessionStart() {
+		return (Date.now() - new Date(this.sessionStart).getTime()) / (1e3 * 60 * 60);
+	}
+};
+function round(n, decimals = 4) {
+	const factor = 10 ** decimals;
+	return Math.round(n * factor) / factor;
+}
+var ResourceMonitor = class {
+	limits;
+	lastCpuInfo = null;
+	lastCpuTime = 0;
+	pollTimer = null;
+	currentSnapshot;
+	bytesTransferred = 0;
+	lastBandwidthCheck = Date.now();
+	constructor(limits) {
+		this.limits = limits;
+		this.currentSnapshot = {
+			cpuPercent: 0,
+			ramMB: 0,
+			bandwidthMbps: 0,
+			timestamp: Date.now()
+		};
+	}
+	/** Start polling resource usage. */
+	start(intervalMs = 2e3) {
+		this.lastCpuInfo = os.cpus();
+		this.lastCpuTime = Date.now();
+		this.poll();
+		this.pollTimer = setInterval(() => this.poll(), intervalMs);
+	}
+	/** Stop polling. */
+	stop() {
+		if (this.pollTimer) {
+			clearInterval(this.pollTimer);
+			this.pollTimer = null;
+		}
+	}
+	/** Record bytes transferred for bandwidth estimation. */
+	recordBytes(bytes) {
+		this.bytesTransferred += bytes;
+	}
+	/** Get the latest resource snapshot. */
+	getSnapshot() {
+		return { ...this.currentSnapshot };
+	}
+	/** Check whether we have capacity to accept a new task. */
+	hasCapacity() {
+		const snap = this.currentSnapshot;
+		return snap.cpuPercent < this.limits.maxCpuPercent && snap.ramMB < this.limits.maxRamMB && snap.bandwidthMbps < this.limits.maxBandwidthMbps;
+	}
+	/** Get the current resource limits. */
+	getLimits() {
+		return { ...this.limits };
+	}
+	/** Update limits at runtime (e.g. user changes config). */
+	updateLimits(limits) {
+		this.limits = {
+			...this.limits,
+			...limits
+		};
+	}
+	poll() {
+		const now = Date.now();
+		const cpus2 = os.cpus();
+		let cpuPercent = 0;
+		if (this.lastCpuInfo && cpus2.length > 0) {
+			let totalDiff = 0;
+			let idleDiff = 0;
+			for (let i = 0; i < cpus2.length; i++) {
+				const prev = this.lastCpuInfo[i];
+				const curr = cpus2[i];
+				if (!prev || !curr) continue;
+				const prevTotal = prev.times.user + prev.times.nice + prev.times.sys + prev.times.idle + prev.times.irq;
+				const currTotal = curr.times.user + curr.times.nice + curr.times.sys + curr.times.idle + curr.times.irq;
+				totalDiff += currTotal - prevTotal;
+				idleDiff += curr.times.idle - prev.times.idle;
+			}
+			if (totalDiff > 0) cpuPercent = Math.round((totalDiff - idleDiff) / totalDiff * 100);
+		}
+		this.lastCpuInfo = cpus2;
+		this.lastCpuTime = now;
+		const ramMB = Math.round(process.memoryUsage.rss() / (1024 * 1024));
+		const bwElapsed = (now - this.lastBandwidthCheck) / 1e3;
+		let bandwidthMbps = 0;
+		if (bwElapsed > 0) {
+			bandwidthMbps = Math.round(this.bytesTransferred * 8 / (bwElapsed * 1e6) * 100) / 100;
+			this.bytesTransferred = 0;
+			this.lastBandwidthCheck = now;
+		}
+		this.currentSnapshot = {
+			cpuPercent,
+			ramMB,
+			bandwidthMbps,
+			timestamp: now
+		};
+	}
+};
+var TaskProcessor = class {
+	monitor;
+	activeTasks = /* @__PURE__ */ new Map();
+	signFn;
+	constructor(monitor, signFn) {
+		this.monitor = monitor;
+		this.signFn = signFn;
+	}
+	/** Check whether the node can accept a task right now. */
+	canAccept(task) {
+		if (!this.monitor.hasCapacity()) return false;
+		if (Date.now() > task.deadline) return false;
+		if (this.activeTasks.size >= 5) return false;
+		return true;
+	}
+	/** Process a task and return the result. */
+	async process(task) {
+		this.activeTasks.set(task.id, task);
+		const start = Date.now();
+		try {
+			let output;
+			switch (task.payload.kind) {
+				case "ping":
+					output = await this.processPing(task.payload);
+					break;
+				case "relay":
+					output = await this.processRelay(task.payload);
+					break;
+				case "compute":
+					output = await this.processCompute(task.payload);
+					break;
+				case "store":
+					output = await this.processStore(task.payload);
+					break;
+				case "validate":
+					output = this.processValidate(task.payload);
+					break;
+				default: throw new Error(`Unknown task type: ${task.payload.kind}`);
+			}
+			const durationMs = Date.now() - start;
+			const proof = this.generateProof(task.id, output, durationMs);
+			return {
+				taskId: task.id,
+				success: true,
+				output,
+				durationMs,
+				proof
+			};
+		} catch (error) {
+			const durationMs = Date.now() - start;
+			return {
+				taskId: task.id,
+				success: false,
+				output: error instanceof Error ? error.message : "Unknown error",
+				durationMs,
+				proof: ""
+			};
+		} finally {
+			this.activeTasks.delete(task.id);
+		}
+	}
+	/** Get number of currently active tasks. */
+	getActiveCount() {
+		return this.activeTasks.size;
+	}
+	async processPing(payload) {
+		const start = Date.now();
+		try {
+			const response = await fetch(payload.target, {
+				method: "HEAD",
+				signal: AbortSignal.timeout(1e4)
+			});
+			const latencyMs = Date.now() - start;
+			const success = response.status === payload.expectedStatusCode;
+			return JSON.stringify({
+				status: response.status,
+				latencyMs,
+				success
+			});
+		} catch (error) {
+			const latencyMs = Date.now() - start;
+			return JSON.stringify({
+				status: 0,
+				latencyMs,
+				success: false,
+				error: error instanceof Error ? error.message : "timeout"
+			});
+		}
+	}
+	async processRelay(payload) {
+		const sourceResp = await fetch(payload.sourceUrl, { signal: AbortSignal.timeout(3e4) });
+		if (!sourceResp.ok) throw new Error(`Source fetch failed: ${sourceResp.status}`);
+		const body = await sourceResp.arrayBuffer();
+		this.monitor.recordBytes(body.byteLength);
+		const destResp = await fetch(payload.destinationUrl, {
+			method: "POST",
+			body,
+			signal: AbortSignal.timeout(3e4)
+		});
+		this.monitor.recordBytes(body.byteLength);
+		return JSON.stringify({
+			bytesRelayed: body.byteLength,
+			destinationStatus: destResp.status,
+			success: destResp.ok
+		});
+	}
+	async processCompute(payload) {
+		const timeoutMs = Math.min(payload.timeoutMs, 3e4);
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Compute task timed out"));
+			}, timeoutMs);
+			try {
+				const hash = crypto.createHash("sha256").update(payload.workload).update(payload.input).digest("hex");
+				clearTimeout(timer);
+				resolve(JSON.stringify({
+					resultHash: hash,
+					inputLength: payload.input.length
+				}));
+			} catch (error) {
+				clearTimeout(timer);
+				reject(error);
+			}
+		});
+	}
+	async processStore(payload) {
+		const data = Buffer.from(payload.data, "base64");
+		const hash = crypto.createHash("sha256").update(data).digest("hex");
+		this.monitor.recordBytes(data.byteLength);
+		return JSON.stringify({
+			chunkId: payload.chunkId,
+			sizeBytes: data.byteLength,
+			hash,
+			ttlSec: payload.ttlSec,
+			stored: true
+		});
+	}
+	processValidate(payload) {
+		const actualHash = crypto.createHash("sha256").update(payload.resultData).digest("hex");
+		const valid = actualHash === payload.expectedHash;
+		return JSON.stringify({
+			resultId: payload.resultId,
+			expectedHash: payload.expectedHash,
+			actualHash,
+			valid
+		});
+	}
+	/** Generate a signed proof-of-work for the completed task. */
+	generateProof(taskId, output, durationMs) {
+		const proofData = `${taskId}:${crypto.createHash("sha256").update(output).digest("hex")}:${durationMs}`;
+		return `${proofData}:${this.signFn(proofData).toString("base64")}`;
+	}
+};
+var UCUWallet = class _UCUWallet {
+	publicKey;
+	privateKey;
+	balance = 0;
+	pendingBalance = 0;
+	totalEarned = 0;
+	lastPayout = null;
+	stateFile;
+	constructor(publicKey, privateKey, stateFile) {
+		this.publicKey = publicKey;
+		this.privateKey = privateKey;
+		this.stateFile = stateFile;
+	}
+	/**
+	* Load or create a wallet from the given data directory.
+	* If a keypair exists on disk, it is loaded. Otherwise a new
+	* Ed25519 keypair is generated and saved.
+	*/
+	static async init(dataDir) {
+		const keyFile = path.join(dataDir, "wallet.key");
+		const stateFile = path.join(dataDir, "wallet.json");
+		fs.mkdirSync(dataDir, { recursive: true });
+		let publicKey;
+		let privateKey;
+		if (fs.existsSync(keyFile)) {
+			const raw = fs.readFileSync(keyFile, "utf-8");
+			const parsed = JSON.parse(raw);
+			publicKey = parsed.publicKey;
+			privateKey = crypto.createPrivateKey({
+				key: Buffer.from(parsed.privateKey, "base64"),
+				format: "der",
+				type: "pkcs8"
+			});
+		} else {
+			const pair = crypto.generateKeyPairSync("ed25519");
+			const pubDer = pair.publicKey.export({
+				type: "spki",
+				format: "der"
+			}).toString("base64");
+			const privDer = pair.privateKey.export({
+				type: "pkcs8",
+				format: "der"
+			}).toString("base64");
+			publicKey = pubDer;
+			privateKey = pair.privateKey;
+			fs.writeFileSync(keyFile, JSON.stringify({
+				publicKey: pubDer,
+				privateKey: privDer
+			}), { mode: 384 });
+		}
+		const wallet = new _UCUWallet(publicKey, privateKey, stateFile);
+		if (fs.existsSync(stateFile)) try {
+			const saved = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+			wallet.balance = saved.balance ?? 0;
+			wallet.pendingBalance = saved.pendingBalance ?? 0;
+			wallet.totalEarned = saved.totalEarned ?? 0;
+			wallet.lastPayout = saved.lastPayout ?? null;
+		} catch {}
+		return wallet;
+	}
+	/** Get the node's public key (base64 DER). */
+	getPublicKey() {
+		return this.publicKey;
+	}
+	/** Get a short node ID derived from the public key. */
+	getNodeId() {
+		return `svrn-${crypto.createHash("sha256").update(this.publicKey).digest("hex").slice(0, 12)}`;
+	}
+	/** Sign arbitrary data with the node's private key. */
+	sign(data) {
+		return crypto.sign(null, Buffer.from(data), this.privateKey);
+	}
+	/** Credit UCU for a completed task. */
+	credit(amount) {
+		this.balance += amount;
+		this.totalEarned += amount;
+		this.lastPayout = (/* @__PURE__ */ new Date()).toISOString();
+		this.persist();
+	}
+	/** Move amount from balance to pending (e.g. withdrawal request). */
+	reserve(amount) {
+		if (amount > this.balance) return false;
+		this.balance -= amount;
+		this.pendingBalance += amount;
+		this.persist();
+		return true;
+	}
+	/** Confirm a pending withdrawal. */
+	confirmWithdrawal(amount) {
+		this.pendingBalance = Math.max(0, this.pendingBalance - amount);
+		this.persist();
+	}
+	/** Get the current wallet state. */
+	getState() {
+		return {
+			publicKey: this.publicKey,
+			balance: this.balance,
+			pendingBalance: this.pendingBalance,
+			totalEarned: this.totalEarned,
+			lastPayout: this.lastPayout
+		};
+	}
+	/** Persist wallet state to disk. */
+	persist() {
+		try {
+			fs.writeFileSync(this.stateFile, JSON.stringify({
+				publicKey: this.publicKey,
+				balance: this.balance,
+				pendingBalance: this.pendingBalance,
+				totalEarned: this.totalEarned,
+				lastPayout: this.lastPayout
+			}, null, 2));
+		} catch {}
+	}
+};
+var SVRNNode = class extends EventEmitter {
+	config;
+	state = "stopped";
+	startTime = 0;
+	wallet;
+	monitor;
+	processor;
+	earnings;
+	updater;
+	heartbeatTimer = null;
+	coordinatorConnected = false;
+	constructor(config) {
+		super();
+		this.config = resolveConfig(config);
+	}
+	/** Start the SVRN node. */
+	async start() {
+		if (this.state !== "stopped") throw new Error(`Cannot start: node is ${this.state}`);
+		this.state = "starting";
+		this.emit("state-change", this.state);
+		this.wallet = await UCUWallet.init(this.config.dataDir);
+		this.monitor = new ResourceMonitor(this.config.resources);
+		this.processor = new TaskProcessor(this.monitor, (data) => this.wallet.sign(data));
+		this.earnings = new EarningsTracker(this.config.dataDir);
+		this.updater = new AutoUpdater(this.config.autoUpdate, this.config.dataDir);
+		this.updater.on("update-available", (info) => {
+			this.emit("update-available", info);
+		});
+		this.updater.on("update-installed", (info) => {
+			this.emit("update-installed", info);
+		});
+		this.monitor.start();
+		this.updater.start();
+		this.startHeartbeat();
+		this.startTime = Date.now();
+		this.state = "running";
+		this.emit("state-change", this.state);
+		this.emit("started", this.getNodeId());
+	}
+	/** Stop the SVRN node gracefully. */
+	async stop() {
+		if (this.state !== "running") return;
+		this.state = "stopping";
+		this.emit("state-change", this.state);
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
+		}
+		this.monitor.stop();
+		this.updater.stop();
+		await this.deregisterFromCoordinator().catch(() => {});
+		this.state = "stopped";
+		this.emit("state-change", this.state);
+		this.emit("stopped");
+	}
+	/** Get the node's unique ID. */
+	getNodeId() {
+		return this.config.nodeId ?? this.wallet?.getNodeId() ?? "unknown";
+	}
+	/** Get the current node status. */
+	getStatus() {
+		const uptime = this.state === "running" ? Math.floor((Date.now() - this.startTime) / 1e3) : 0;
+		return {
+			state: this.state,
+			nodeId: this.getNodeId(),
+			uptime,
+			resources: this.monitor?.getSnapshot() ?? {
+				cpuPercent: 0,
+				ramMB: 0,
+				bandwidthMbps: 0,
+				timestamp: Date.now()
+			},
+			earnings: this.earnings?.getSummary() ?? {
+				session: 0,
+				today: 0,
+				allTime: 0,
+				tasksThisSession: 0,
+				tasksToday: 0,
+				tasksAllTime: 0,
+				estimatedMonthlySavingsUSD: 0,
+				estimatedAnnualSavingsUSD: 0
+			},
+			wallet: this.wallet?.getState() ?? {
+				publicKey: "",
+				balance: 0,
+				pendingBalance: 0,
+				totalEarned: 0,
+				lastPayout: null
+			},
+			activeTasks: this.processor?.getActiveCount() ?? 0,
+			version: this.updater?.getVersion() ?? "0.0.0",
+			connectedToCoordinator: this.coordinatorConnected
+		};
+	}
+	/** Get earnings summary. */
+	getEarnings() {
+		return this.earnings.getSummary();
+	}
+	/** Get wallet state. */
+	getWallet() {
+		return this.wallet.getState();
+	}
+	/** Get resource snapshot. */
+	getResources() {
+		return this.monitor.getSnapshot();
+	}
+	/** Get the list of accepted task types. */
+	getTaskTypes() {
+		return [...this.config.taskTypes];
+	}
+	/** Manually trigger an update check. */
+	async checkForUpdates() {
+		return this.updater.check();
+	}
+	/** Submit a task to this node for processing. */
+	async submitTask(task) {
+		if (this.state !== "running") throw new Error("Node is not running");
+		if (!this.processor.canAccept(task)) throw new Error("Node cannot accept task: at capacity or deadline passed");
+		this.emit("task-received", task);
+		const result = await this.processor.process(task);
+		if (result.success) {
+			this.wallet.credit(task.rewardUCU);
+			this.earnings.record(task.type, task.id, task.rewardUCU, result.durationMs);
+			this.emit("task-completed", result);
+		} else this.emit("task-failed", result);
+		return result;
+	}
+	startHeartbeat() {
+		this.registerWithCoordinator();
+		this.heartbeatTimer = setInterval(() => void this.sendHeartbeat(), this.config.heartbeatIntervalSec * 1e3);
+	}
+	async registerWithCoordinator() {
+		try {
+			const response = await fetch(`${this.config.coordinatorUrl}/api/nodes/register`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					nodeId: this.getNodeId(),
+					publicKey: this.wallet.getPublicKey(),
+					capabilities: this.config.taskTypes,
+					resources: this.monitor.getSnapshot(),
+					version: this.updater.getVersion()
+				}),
+				signal: AbortSignal.timeout(1e4)
+			});
+			this.coordinatorConnected = response.ok;
+			if (response.ok) this.emit("coordinator-connected");
+		} catch {
+			this.coordinatorConnected = false;
+		}
+	}
+	async sendHeartbeat() {
+		try {
+			const response = await fetch(`${this.config.coordinatorUrl}/api/nodes/heartbeat`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					nodeId: this.getNodeId(),
+					resources: this.monitor.getSnapshot(),
+					activeTasks: this.processor.getActiveCount(),
+					earnings: this.earnings.getSummary()
+				}),
+				signal: AbortSignal.timeout(1e4)
+			});
+			const wasConnected = this.coordinatorConnected;
+			this.coordinatorConnected = response.ok;
+			if (!wasConnected && response.ok) this.emit("coordinator-connected");
+			else if (wasConnected && !response.ok) this.emit("coordinator-disconnected");
+			if (response.ok) {
+				const data = await response.json();
+				if (data.tasks && Array.isArray(data.tasks)) for (const task of data.tasks) this.submitTask(task);
+			}
+		} catch {
+			if (this.coordinatorConnected) {
+				this.coordinatorConnected = false;
+				this.emit("coordinator-disconnected");
+			}
+		}
+	}
+	async deregisterFromCoordinator() {
+		try {
+			await fetch(`${this.config.coordinatorUrl}/api/nodes/deregister`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ nodeId: this.getNodeId() }),
+				signal: AbortSignal.timeout(5e3)
+			});
+		} catch {}
+	}
+};
+function createNode(config) {
+	return new SVRNNode(config);
+}
+async function startNode(config) {
+	const node = createNode(config);
+	await node.start();
+	return node;
+}
+
+//#endregion
+export { ALL_TASK_TYPES, AutoUpdater, DEFAULT_CONFIG, EarningsTracker, ResourceMonitor, SVRNNode, TaskProcessor, UCUWallet, createNode, resolveConfig, startNode };