infinicode 1.0.0 → 2.0.0

package/dist/kernel/event-bus.d.ts

@@ -0,0 +1,19 @@
+/**
+ * OpenKernel — Event Bus
+ *
+ * Everything emits events. Plugins subscribe.
+ */
+import type { EventHandler, KernelEvent, KernelEventType } from './types.js';
+export declare class EventBus {
+    private handlers;
+    private wildcardHandlers;
+    private history;
+    private maxHistory;
+    on(types: KernelEventType[], handler: EventHandler): () => void;
+    onAll(handler: EventHandler): () => void;
+    emit(event: KernelEvent): void;
+    private invoke;
+    private emitSafe;
+    getHistory(): KernelEvent[];
+    clearHistory(): void;
+}

package/dist/kernel/event-bus.js

@@ -0,0 +1,65 @@
+export class EventBus {
+    handlers = new Map();
+    wildcardHandlers = new Set();
+    history = [];
+    maxHistory = 1000;
+    on(types, handler) {
+        for (const type of types) {
+            let set = this.handlers.get(type);
+            if (!set) {
+                set = new Set();
+                this.handlers.set(type, set);
+            }
+            set.add(handler);
+        }
+        return () => {
+            for (const type of types) {
+                this.handlers.get(type)?.delete(handler);
+            }
+        };
+    }
+    onAll(handler) {
+        this.wildcardHandlers.add(handler);
+        return () => this.wildcardHandlers.delete(handler);
+    }
+    emit(event) {
+        this.history.push(event);
+        if (this.history.length > this.maxHistory) {
+            this.history.shift();
+        }
+        const typeHandlers = this.handlers.get(event.type);
+        if (typeHandlers) {
+            for (const handler of typeHandlers) {
+                this.invoke(handler, event);
+            }
+        }
+        for (const handler of this.wildcardHandlers) {
+            this.invoke(handler, event);
+        }
+    }
+    invoke(handler, event) {
+        try {
+            const result = handler(event);
+            if (result instanceof Promise) {
+                result.catch(err => this.emitSafe('LOG', { message: `Event handler error: ${err}` }));
+            }
+        }
+        catch (err) {
+            this.emitSafe('LOG', { message: `Event handler error: ${err}` });
+        }
+    }
+    emitSafe(type, data) {
+        try {
+            this.emit({ type, timestamp: Date.now(), data });
+        }
+        catch {
+            // swallow
+        }
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    clearHistory() {
+        this.history = [];
+    }
+}

package/dist/kernel/federation/auto-update.d.ts

@@ -0,0 +1,36 @@
+/**
+ * OpenKernel — Auto Mesh Update
+ *
+ * Version gossip across the mesh. Each node announces its version on connect and
+ * heartbeat; when a node hears of a newer version from a trusted peer it can
+ * (optionally) self-update via the configured channel. Off by default — updating
+ * is opt-in per node, and only accepted from a hub/relay, never from a satellite.
+ */
+import type { Logger } from '../types.js';
+import type { NodeRole, UpdateAnnounce } from './types.js';
+/** Compare two dotted versions. Returns >0 if a>b, <0 if a<b, 0 if equal. */
+export declare function compareVersions(a: string, b: string): number;
+export interface AutoUpdateOptions {
+    version: string;
+    channel?: UpdateAnnounce['channel'];
+    ref?: string;
+    logger: Logger;
+    /** When true, act on a newer announce; otherwise just log availability. */
+    enabled?: boolean;
+    /** Perform the actual update (npm i -g, git pull, download). Caller-supplied
+     *  so the kernel never shells out unexpectedly. */
+    applyUpdate?: (announce: UpdateAnnounce) => Promise<void>;
+}
+export declare class AutoUpdate {
+    private opts;
+    private latestSeen;
+    constructor(opts: AutoUpdateOptions);
+    /** This node's announcement. */
+    announce(): UpdateAnnounce;
+    /**
+     * Process a peer's announce. Returns true if an update was (or would be)
+     * triggered. Only honours announcements from hub/relay roles.
+     */
+    onAnnounce(announce: UpdateAnnounce, fromRole: NodeRole): Promise<boolean>;
+    currentVersion(): string;
+}

package/dist/kernel/federation/auto-update.js

@@ -0,0 +1,57 @@
+/** Compare two dotted versions. Returns >0 if a>b, <0 if a<b, 0 if equal. */
+export function compareVersions(a, b) {
+    const pa = a.split('.').map(n => parseInt(n, 10) || 0);
+    const pb = b.split('.').map(n => parseInt(n, 10) || 0);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+export class AutoUpdate {
+    opts;
+    latestSeen;
+    constructor(opts) {
+        this.opts = opts;
+        this.latestSeen = opts.version;
+    }
+    /** This node's announcement. */
+    announce() {
+        return {
+            version: this.opts.version,
+            channel: this.opts.channel ?? 'npm',
+            ref: this.opts.ref,
+        };
+    }
+    /**
+     * Process a peer's announce. Returns true if an update was (or would be)
+     * triggered. Only honours announcements from hub/relay roles.
+     */
+    async onAnnounce(announce, fromRole) {
+        if (compareVersions(announce.version, this.latestSeen) <= 0)
+            return false;
+        this.latestSeen = announce.version;
+        if (fromRole !== 'hub' && fromRole !== 'relay') {
+            this.opts.logger.info(`[federation] newer version ${announce.version} seen from ${fromRole} (ignored — not a hub/relay)`);
+            return false;
+        }
+        if (!this.opts.enabled) {
+            this.opts.logger.info(`[federation] update available: ${announce.version} (auto-update disabled — run manually)`);
+            return false;
+        }
+        this.opts.logger.info(`[federation] applying update → ${announce.version} via ${announce.channel}`);
+        try {
+            await this.opts.applyUpdate?.(announce);
+            return true;
+        }
+        catch (err) {
+            this.opts.logger.warn(`[federation] update failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
+    currentVersion() {
+        return this.opts.version;
+    }
+}

package/dist/kernel/federation/compute-router.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenKernel — Compute Router (cross-device)
+ *
+ * Given a task's capability needs, rank connected peers by how well they fit:
+ * capability coverage, live load (from telemetry), and latency. This is the
+ * east-west analog of the in-process CapabilityRouter — it decides WHICH DEVICE
+ * runs a task, not which model.
+ */
+import type { Capability } from '../types.js';
+import type { PeerInfo } from './types.js';
+export interface ComputeCandidate {
+    peer: PeerInfo;
+    score: number;
+    reason: string;
+}
+export interface ComputeNeed {
+    capabilities: Capability[];
+    /** Prefer a specific device if named (e.g. "robopanda"). */
+    preferNodeId?: string;
+    preferName?: string;
+}
+export declare class ComputeRouter {
+    /** Rank connected peers for a task. Best first. */
+    rank(peers: PeerInfo[], need: ComputeNeed): ComputeCandidate[];
+    best(peers: PeerInfo[], need: ComputeNeed): PeerInfo | null;
+    private coverage;
+}

package/dist/kernel/federation/compute-router.js

@@ -0,0 +1,44 @@
+import { loadFromSnapshot } from './telemetry.js';
+export class ComputeRouter {
+    /** Rank connected peers for a task. Best first. */
+    rank(peers, need) {
+        const candidates = [];
+        for (const peer of peers) {
+            if (!peer.connected)
+                continue;
+            const caps = peer.manifest?.capabilities ?? [];
+            const coverage = this.coverage(caps, need.capabilities);
+            if (coverage === 0 && need.capabilities.length > 0)
+                continue;
+            const load = loadFromSnapshot(peer.hardware); // 0–100
+            const latency = peer.latencyMs ?? 500;
+            let score = coverage * 5 + // capability fit dominates
+                (1 - load / 100) * 3 + // prefer idle devices
+                (1 - Math.min(1, latency / 2000)); // prefer nearby devices
+            // Explicit device preference wins big.
+            if (need.preferNodeId && peer.nodeId === need.preferNodeId)
+                score += 100;
+            if (need.preferName && peer.displayName.toLowerCase() === need.preferName.toLowerCase())
+                score += 100;
+            candidates.push({
+                peer,
+                score,
+                reason: `cap=${coverage.toFixed(2)} load=${load} lat=${latency}ms`,
+            });
+        }
+        return candidates.sort((a, b) => b.score - a.score);
+    }
+    best(peers, need) {
+        return this.rank(peers, need)[0]?.peer ?? null;
+    }
+    coverage(have, want) {
+        if (want.length === 0)
+            return 0.5;
+        const set = new Set(have);
+        let hit = 0;
+        for (const c of want)
+            if (set.has(c))
+                hit++;
+        return hit / want.length;
+    }
+}

package/dist/kernel/federation/config-sync.d.ts

@@ -0,0 +1,33 @@
+/**
+ * OpenKernel — Config Sync (API / provider sharing)
+ *
+ * A hub holds a SharedConfig (cloud providers + API keys, policy, default model)
+ * with a monotonic revision. Satellites request it on connect and re-apply only
+ * when the revision changes — so you set API keys once on the hub and the whole
+ * fleet inherits them, no per-device key management.
+ *
+ * Sensitive: the shared config carries API keys. It only travels over the
+ * admin-opened, optionally-tokened transport, and satellites persist it locally
+ * via the apply callback (which the federation manager wires to provider
+ * registration + the local config file).
+ */
+import type { Logger } from '../types.js';
+import type { SharedConfig } from './types.js';
+export interface ConfigSyncOptions {
+    logger: Logger;
+    /** Apply an incoming shared config on a satellite (register providers, etc.). */
+    apply?: (cfg: SharedConfig) => void | Promise<void>;
+}
+export declare class ConfigSync {
+    private opts;
+    private shared;
+    private appliedRevision;
+    constructor(opts: ConfigSyncOptions);
+    /** Hub: publish a new shared config (bumps revision). */
+    publish(cfg: Omit<SharedConfig, 'revision' | 'updatedAt'>): SharedConfig;
+    /** Hub: current offer to satisfy a config.request. */
+    offer(): SharedConfig;
+    /** Satellite: receive a hub's offer; apply only if newer than what we have. */
+    receive(cfg: SharedConfig): Promise<boolean>;
+    currentRevision(): number;
+}

package/dist/kernel/federation/config-sync.js

@@ -0,0 +1,37 @@
+export class ConfigSync {
+    opts;
+    shared = { revision: 0, updatedAt: Date.now() };
+    appliedRevision = -1;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Hub: publish a new shared config (bumps revision). */
+    publish(cfg) {
+        this.shared = { ...cfg, revision: this.shared.revision + 1, updatedAt: Date.now() };
+        this.opts.logger.info(`[federation] shared config published (rev ${this.shared.revision})`);
+        return this.shared;
+    }
+    /** Hub: current offer to satisfy a config.request. */
+    offer() {
+        return this.shared;
+    }
+    /** Satellite: receive a hub's offer; apply only if newer than what we have. */
+    async receive(cfg) {
+        if (cfg.revision <= this.appliedRevision)
+            return false;
+        this.shared = cfg;
+        this.appliedRevision = cfg.revision;
+        try {
+            await this.opts.apply?.(cfg);
+            this.opts.logger.info(`[federation] applied shared config (rev ${cfg.revision})`);
+            return true;
+        }
+        catch (err) {
+            this.opts.logger.warn(`[federation] apply config failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
+    currentRevision() {
+        return this.shared.revision;
+    }
+}

package/dist/kernel/federation/discovery.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '../types.js';
+export interface DiscoverOptions {
+    port: number;
+    /** Only include peers carrying this Tailscale ACL tag (e.g. "tag:robopark"). */
+    tag?: string;
+    logger?: Logger;
+}
+/** Return mesh base URLs (http://ip:port) for online Tailscale peers. */
+export declare function discoverTailscalePeers(opts: DiscoverOptions): Promise<string[]>;
+/** True if the Tailscale CLI is available on this host. */
+export declare function tailscaleAvailable(): Promise<boolean>;

package/dist/kernel/federation/discovery.js

@@ -0,0 +1,44 @@
+/**
+ * OpenKernel — Peer Discovery
+ *
+ * Tailscale-based auto-discovery so `serve`/`mcp` find peers without --seed.
+ * Runs `tailscale status --json` and returns candidate mesh base URLs for
+ * online peers. Best-effort: if the Tailscale CLI is absent, returns []. LAN
+ * mDNS can be added later; Tailscale covers the LAN+remote mix directly.
+ */
+import { execa } from 'execa';
+/** Return mesh base URLs (http://ip:port) for online Tailscale peers. */
+export async function discoverTailscalePeers(opts) {
+    let status;
+    try {
+        const { stdout } = await execa('tailscale', ['status', '--json'], { timeout: 5000 });
+        status = JSON.parse(stdout);
+    }
+    catch (err) {
+        opts.logger?.debug?.(`[federation] tailscale discovery unavailable: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+    const urls = [];
+    for (const peer of Object.values(status.Peer ?? {})) {
+        if (!peer.Online)
+            continue;
+        if (opts.tag && !(peer.Tags ?? []).includes(opts.tag))
+            continue;
+        const ip = (peer.TailscaleIPs ?? []).find(a => a.includes('.')); // prefer IPv4
+        if (!ip)
+            continue;
+        urls.push(`http://${ip}:${opts.port}`);
+    }
+    opts.logger?.info?.(`[federation] tailscale discovery found ${urls.length} peer(s)`);
+    return urls;
+}
+/** True if the Tailscale CLI is available on this host. */
+export async function tailscaleAvailable() {
+    try {
+        await execa('tailscale', ['version'], { timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/kernel/federation/event-bridge.d.ts

@@ -0,0 +1,30 @@
+/**
+ * OpenKernel — Event Bridge
+ *
+ * Taps the kernel EventBus (via subscribeAll) and turns local events into
+ * compact StreamFrames the mesh broadcasts to connected harnesses. Tuned for
+ * animation: lifecycle events flow immediately (so the map reacts instantly),
+ * while noisy LOG/PROVIDER_HEALTH chatter is coalesced on a short flush timer to
+ * keep the byte-rate low.
+ */
+import type { KernelEvent } from '../types.js';
+import type { StreamFrame } from './types.js';
+export interface EventBridgeOptions {
+    nodeId: string;
+    /** Push a frame onto the mesh (MeshServer.broadcast). */
+    emit: (f: StreamFrame) => void;
+    flushMs?: number;
+}
+export declare class EventBridge {
+    private opts;
+    private buffer;
+    private timer?;
+    constructor(opts: EventBridgeOptions);
+    /** Compact an event to a tiny payload for the wire. */
+    private compact;
+    /** Handle a kernel event (wire this to kernel.subscribeAll). */
+    handle(e: KernelEvent): void;
+    private scheduleFlush;
+    private flush;
+    stop(): void;
+}

package/dist/kernel/federation/event-bridge.js

@@ -0,0 +1,61 @@
+import { frame } from './protocol.js';
+/** Events that should render instantly (map animation triggers). */
+const IMMEDIATE = new Set([
+    'MISSION_STARTED', 'MISSION_COMPLETED', 'MISSION_FAILED',
+    'TASK_STARTED', 'TASK_COMPLETED', 'TASK_FAILED',
+    'WORKER_SPAWNED', 'WORKER_EXITED', 'ROUTING_DECISION', 'RECOVERY', 'NOTIFICATION',
+]);
+/** High-frequency, low-value chatter to coalesce. */
+const COALESCE = new Set(['LOG', 'PROVIDER_HEALTH']);
+export class EventBridge {
+    opts;
+    buffer = [];
+    timer;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Compact an event to a tiny payload for the wire. */
+    compact(e) {
+        return {
+            k: e.type,
+            m: e.missionId,
+            task: e.taskId,
+            w: e.workerId,
+            d: e.data,
+        };
+    }
+    /** Handle a kernel event (wire this to kernel.subscribeAll). */
+    handle(e) {
+        if (COALESCE.has(e.type)) {
+            this.buffer.push(e);
+            this.scheduleFlush();
+            return;
+        }
+        if (IMMEDIATE.has(e.type)) {
+            const t = e.type === 'ROUTING_DECISION' ? 'rt' : 'ev';
+            this.opts.emit(frame(t, this.opts.nodeId, this.compact(e)));
+        }
+        // other events are dropped from the stream (still available via history)
+    }
+    scheduleFlush() {
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => this.flush(), this.opts.flushMs ?? 250);
+    }
+    flush() {
+        this.timer = undefined;
+        if (this.buffer.length === 0)
+            return;
+        const batch = this.buffer.splice(0, this.buffer.length);
+        // One coalesced 'log' frame carrying a count + the last few lines.
+        this.opts.emit(frame('log', this.opts.nodeId, {
+            count: batch.length,
+            tail: batch.slice(-5).map(e => ({ k: e.type, d: e.data })),
+        }));
+    }
+    stop() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.flush();
+    }
+}

package/dist/kernel/federation/federation-plugin.d.ts

@@ -0,0 +1,24 @@
+/**
+ * OpenKernel — Federation Plugin
+ *
+ * Thin wrapper so a harness can enable the mesh via kernel.registerPlugin(...).
+ * The Federation manager already subscribes to events through the kernel it's
+ * given; this plugin just owns its lifecycle (start on register, stop on
+ * destroy) and exposes the running manager for callers that want it.
+ */
+import type { Logger, Plugin } from '../types.js';
+import { Federation, type FederationOptions } from './federation.js';
+import { type ManifestInputs } from './node-identity.js';
+import type { NodeRole } from './types.js';
+export interface FederationPluginOptions extends FederationOptions {
+    role?: NodeRole;
+    displayName?: string;
+    storageDir?: string;
+    logger?: Logger;
+    /** Supplies the manifest inputs (caps/workers/commands/providers). */
+    describe: () => ManifestInputs;
+}
+export interface FederationPlugin extends Plugin {
+    readonly federation: Federation;
+}
+export declare function createFederationPlugin(opts: FederationPluginOptions): FederationPlugin;

package/dist/kernel/federation/federation-plugin.js

@@ -0,0 +1,35 @@
+import { Federation } from './federation.js';
+import { loadOrCreateIdentity } from './node-identity.js';
+export function createFederationPlugin(opts) {
+    const identity = loadOrCreateIdentity({
+        storageDir: opts.storageDir,
+        displayName: opts.displayName,
+        role: opts.role,
+    });
+    let federation;
+    return {
+        get federation() {
+            if (!federation)
+                throw new Error('federation not started');
+            return federation;
+        },
+        manifest: {
+            name: 'federation',
+            version: '0.1.0',
+            description: 'Peer-to-peer device mesh (LAN + Tailscale) — spawn, telemetry, config sync',
+        },
+        async onRegister(kernel) {
+            const logger = opts.logger ?? {
+                debug: () => { },
+                info: (m, ...a) => console.error('[federation]', m, ...a),
+                warn: (m, ...a) => console.error('[federation]', m, ...a),
+                error: (m, ...a) => console.error('[federation]', m, ...a),
+            };
+            federation = new Federation({ kernel, identity, describe: opts.describe, logger, options: opts });
+            await federation.start();
+        },
+        async onDestroy() {
+            await federation?.stop();
+        },
+    };
+}

package/dist/kernel/federation/federation.d.ts

@@ -0,0 +1,126 @@
+/**
+ * OpenKernel — Federation Manager
+ *
+ * The one object that wires the mesh together:
+ *   transport (HTTP+SSE) · peer-mesh · telemetry · event-bridge · config-sync ·
+ *   auto-update · compute-router · MOLTFED emit.
+ *
+ * Lifecycle: build with a KernelLike + a describe() for the manifest, then
+ * start(). It stands up a mesh server, streams local activity/telemetry to
+ * connected harnesses, dispatches tasks to peers, and answers inbound RPC
+ * (heartbeat / task.dispatch / command / config / update).
+ */
+import type { Capability, KernelLike, Logger } from '../types.js';
+import type { HardwareSnapshot, NodeIdentity, NodeStatus, SharedConfig, StreamFrame } from './types.js';
+import { ConfigSync } from './config-sync.js';
+import { AutoUpdate } from './auto-update.js';
+import { ComputeRouter, type ComputeNeed } from './compute-router.js';
+import { type ManifestInputs } from './node-identity.js';
+import { type RoleContext, type RunRecord } from './types.js';
+export interface DispatchTask {
+    description: string;
+    capabilities: Capability[];
+    prompt: string;
+    role?: string;
+    context?: Record<string, unknown>;
+}
+export interface FederationOptions {
+    version: string;
+    port?: number;
+    host?: string;
+    token?: string;
+    heartbeatMs?: number;
+    telemetryMs?: number;
+    /** Base URLs of peers to connect to on start (static seeds). */
+    seeds?: string[];
+    autoUpdate?: boolean;
+    /** Satellite: how to apply an incoming shared config (register providers etc.). */
+    applyConfig?: (cfg: SharedConfig) => void | Promise<void>;
+}
+export interface FederationDeps {
+    kernel: KernelLike;
+    identity: NodeIdentity;
+    describe: () => ManifestInputs;
+    logger: Logger;
+    options: FederationOptions;
+}
+export declare class Federation {
+    private deps;
+    private server?;
+    private client;
+    private mesh?;
+    private bridge?;
+    private telemetry;
+    private telemetryTimer?;
+    private lastHw?;
+    private unsub?;
+    readonly configSync: ConfigSync;
+    readonly autoUpdate: AutoUpdate;
+    readonly compute: ComputeRouter;
+    /** Local subscribers to the merged mesh frame stream (for MCP stream_activity). */
+    private frameSubs;
+    /** Recent frames for catch-up. */
+    private frameHistory;
+    /** Runs received + executing on THIS node (async handoff). */
+    private runs;
+    /** Runs WE dispatched → which peer holds them (for follow_task). */
+    private dispatchedRuns;
+    constructor(deps: FederationDeps);
+    get identity(): NodeIdentity;
+    start(): Promise<void>;
+    private onRpc;
+    getRole(): RoleContext | null;
+    setRole(role: Omit<RoleContext, 'updatedAt'>): RoleContext;
+    getRoleOf(nodeId: string): Promise<RoleContext | null>;
+    setRoleOf(nodeId: string, role: Omit<RoleContext, 'updatedAt'>): Promise<RoleContext>;
+    /** Execute a dispatched task on THIS node via the local kernel. */
+    private runTask;
+    /** Run a dispatched task in the background, updating its RunRecord + streaming. */
+    private runTaskAsync;
+    /**
+     * Hand a task to the best-fit connected peer (compute-routed) or a named one.
+     * Non-blocking by default — returns a runId to follow. Pass wait to block
+     * until the run finishes (short tasks).
+     */
+    dispatch(task: DispatchTask, need?: Partial<ComputeNeed>, opts?: {
+        wait?: boolean;
+        timeoutMs?: number;
+    }): Promise<{
+        peerId: string;
+        runId: string;
+        record: RunRecord;
+    } | null>;
+    /** Query a dispatched run's current record (from whichever peer holds it). */
+    followRun(runId: string): Promise<{
+        record: RunRecord;
+        frames: Array<{
+            peerId: string;
+            f: StreamFrame;
+        }>;
+    } | null>;
+    /** Poll a run until it finishes or the timeout elapses. */
+    awaitRun(runId: string, timeoutMs?: number): Promise<RunRecord>;
+    /** Run a slash-command on a specific peer. */
+    runCommandOn(nodeId: string, input: string): Promise<unknown>;
+    /** Hub: publish shared config (providers/API keys/policy) to the fleet. */
+    publishConfig(cfg: Omit<SharedConfig, 'revision' | 'updatedAt'>): SharedConfig;
+    /** Satellite: pull shared config from a peer (usually the hub). */
+    pullConfig(nodeId: string): Promise<boolean>;
+    connect(url: string): Promise<import("./types.js").PeerInfo | null>;
+    /** Auto-discover peers over Tailscale and connect to each (skips self/known). */
+    discoverAndConnect(tag?: string): Promise<number>;
+    /** Neutral node-status list (self + peers) — feeds the mesh map. */
+    nodeStatuses(): NodeStatus[];
+    peers(): import("./types.js").PeerInfo[];
+    /** Latest local hardware snapshot (for the MOLTFED connector / panels). */
+    latestHardware(): HardwareSnapshot | undefined;
+    /** Subscribe to the merged mesh frame stream (local + peer frames). */
+    onFrames(sub: (peerId: string, f: StreamFrame) => void): () => void;
+    recentFrames(n?: number): Array<{
+        peerId: string;
+        f: StreamFrame;
+    }>;
+    private ingestFrame;
+    private emitLocal;
+    stop(): Promise<void>;
+}