@rljson/server 0.0.9 → 0.0.11

package/README.architecture.md

@@ -77,6 +77,41 @@ In default setups you can reuse a single socket for all four channels; the code
 
 ## Core Components
 
+### 0. Node (Self-Organizing Orchestrator)
+
+The `Node` class sits above `Server` and `Client`, bridging `@rljson/network` topology events into role transitions. It:
+
+1. **Owns storage**: Creates a single `IoMem`/`BsMem` pair at `start()`, reused across all role transitions. Data survives hub↔client switches because `IoMem.close()` only flips `_isOpen` — the in-memory data is never cleared.
+2. **Reacts to topology**: Subscribes to `NetworkManager`'s `role-changed` event. On `'hub'`, tears down any Client and creates a Server. On `'client'`, tears down any Server and creates a Client.
+3. **Manages transport**: Uses injectable factories (`CreateHubTransport`/`CreateClientTransport`) to create the transport layer, keeping the Node class transport-agnostic.
+4. **Agent lifecycle**: An optional `createAgent` factory in `NodeDeps` is called on every `ready` event. The returned `AgentHandle.stop()` is called before the next role transition. This enables application-level wiring (e.g. FsAgent) without circular dependencies.
+5. **Serialized transitions**: Role transitions are queued — a new `role-changed` event waits for the previous transition to complete before starting. This prevents race conditions between teardown and setup.
+6. **Error resilience**: Errors in user-provided code (agent factories, transport factories) are caught and logged. The node continues functioning — a failed transport degrades connectivity but doesn't crash, a failed agent leaves the node's core intact.
+
+```text
+┌─────────────────────────────────────────┐
+│ Node                                    │
+│  ┌──────┐ ┌──────┐                      │
+│  │IoMem │ │BsMem │ ← owned by Node      │
+│  └──┬───┘ └──┬───┘                      │
+│     │        │                           │
+│  ┌──▼────────▼───┐  ┌────────────────┐  │
+│  │ Server/Client │──│ HubTransport   │  │
+│  │ (role-based)  │  │ or ClientSocket│  │
+│  └───────┬───────┘  └────────────────┘  │
+│          │                               │
+│  ┌───────▼───────┐                       │
+│  │ AgentHandle   │  ← optional, wired    │
+│  │ (e.g. FsAgent)│    via createAgent    │
+│  └───────────────┘                       │
+│     ▲                                    │
+│     │ role-changed                       │
+│  ┌──┴───────────┐                        │
+│  │NetworkManager│                        │
+│  └──────────────┘                        │
+└─────────────────────────────────────────┘
+```
+
 ### 1. Client
 
 The `Client` class provides a unified interface for data access by combining local storage with server storage.

package/README.public.md

@@ -164,6 +164,9 @@ This is implemented with `IoMulti` and `BsMulti` internally, but the public API
 - `connector` – Connector wired to the route and socket (available when route was provided)
 - `route` – the Route passed to the constructor
 - `logger` – the `ServerLogger` instance (defaults to `noopLogger`)
+- `isConnected` – whether the socket is currently connected (tracks `disconnect`/`connect` events)
+- `onDisconnect(callback)` – registers a callback that fires when the socket disconnects (receives the reason string)
+- `onReconnect(callback)` – registers a callback that fires when the socket reconnects after a previous disconnect
 
 ### Server API
 
@@ -216,6 +219,60 @@ The same pattern is used for Bs (blob storage).
 - Peer initialization is guarded by a configurable timeout (`peerInitTimeoutMs`, default 30 s) on both server and client. On the server it prevents `addSocket()` from hanging on unresponsive clients; on the client it prevents `init()` from hanging when the server is unreachable.
 - Logging is opt-in via `{ logger }` options. Use `ConsoleLogger` for development, `BufferedLogger` for testing, `FilteredLogger` for production. Default is `NoopLogger` (zero overhead).
 
+## Reconnect handling
+
+The `Client` class tracks socket connection state and provides hooks for upper layers to react to disconnects and reconnections.
+
+### How it works
+
+Socket.IO auto-reconnects at the transport level by default. When the connection drops and is restored:
+
+1. The client-side Socket.IO socket emits `'disconnect'` then (later) `'connect'`.
+2. The `Client` class listens for these events and updates `isConnected`.
+3. Registered `onDisconnect` / `onReconnect` callbacks fire.
+4. The server auto-detects the dropped socket (`removeSocket`) and re-registers the reconnected socket via a new `'connection'` event.
+5. The server sends a bootstrap ref to the reconnected client, triggering a re-sync via the Connector's bootstrap handler.
+
+### Usage
+
+```ts
+import { Client } from '@rljson/server';
+
+const client = new Client(socket, io, bs, route, {
+  logger: new ConsoleLogger(),
+});
+await client.init();
+
+// Track connection state
+console.log(client.isConnected); // true
+
+// React to disconnects
+client.onDisconnect((reason) => {
+  console.warn(`Disconnected: ${reason}`);
+  // Pause user-facing sync indicators, queue local changes, etc.
+});
+
+// React to reconnections
+client.onReconnect(() => {
+  console.info('Reconnected to server');
+  // Resume sync, trigger re-fetch, update UI, etc.
+});
+```
+
+### What survives a reconnect
+
+| Layer             | Survives? | Details                                                           |
+| ----------------- | --------- | ----------------------------------------------------------------- |
+| Socket.IO         | ✅         | Auto-reconnects, reuses the same client-side socket object        |
+| SocketIoBridge    | ✅         | Wraps the same socket — event listeners are preserved             |
+| IoPeer / BsPeer   | ✅         | Listeners remain on the client socket; server re-creates its side |
+| Connector         | ✅         | Listeners remain; server bootstrap re-syncs state                 |
+| IoMulti / BsMulti | ✅         | Multi layers are unaffected; local Io/Bs always available         |
+
+### Cleanup
+
+All connection handlers are cleaned up automatically on `tearDown()`. After tearDown, no callbacks will fire.
+
 ## Logging
 
 Both `Server` and `Client` support structured logging via an injectable `ServerLogger` interface. Logging is opt-in — by default a zero-overhead `NoopLogger` is used.
@@ -580,6 +637,84 @@ await server.removeSocket(clientIds[0]);
 // Automatic: clients are removed when their socket emits 'disconnect'
 ```
 
+## Self-Organizing Node
+
+The `Node` class bridges `@rljson/network` peer discovery with `Server`/`Client` role transitions. Every node runs the same code — on startup it discovers peers, elects a hub, and automatically assumes the correct role.
+
+### Quick start
+
+```ts
+import { Node } from '@rljson/server';
+import { Route } from '@rljson/rljson';
+
+const node = new Node(
+  {
+    domain: 'my-app',
+    port: 3000,
+    route: Route.fromFlat('/sharedTree'),
+  },
+  {
+    createHubTransport: async (port) => { /* start HTTP+Socket.IO server */ },
+    createClientTransport: async (hubAddress) => { /* connect to hub */ },
+  },
+);
+
+await node.start();
+
+// The node auto-discovers peers and assumes a role:
+node.on('ready', ({ role, client, server, socket }) => {
+  console.log(`Role: ${role}`);          // 'hub' or 'client'
+  console.log(`Server: ${server}`);      // Server instance (hub only)
+  console.log(`Client: ${client}`);      // Client instance (client only)
+  console.log(`Socket: ${socket}`);      // Socket to hub (client only)
+});
+```
+
+### Data preservation across role transitions
+
+The `Node` owns a single `IoMem`/`BsMem` pair, created once at `start()` and reused across all role transitions. When a role changes (e.g., hub → client → hub), the underlying storage is re-initialized without losing data — `IoMem.close()` only sets `_isOpen = false`, the data in memory is preserved.
+
+This means:
+- Data written while hub survives a transition to client
+- Data written while client survives a transition to hub
+- A re-elected hub still serves all previously stored blobs and tables
+
+### Agent lifecycle
+
+The `createAgent` factory in `NodeDeps` is called on every role transition. The returned `AgentHandle.stop()` is called before the next transition or when the node stops. This is how you wire application-level agents (e.g. `FsAgent`) without creating circular dependencies:
+
+```ts
+const node = new Node(config, {
+  createHubTransport: ...,
+  createClientTransport: ...,
+  createAgent: async ({ role, client, server, socket }) => {
+    // Wire your agent here — called on every role transition
+    const stopSync = await startMySync(role, client, server);
+    return { stop: () => stopSync() };
+  },
+});
+```
+
+The Node serializes transitions — a new transition waits for the previous one to complete, ensuring agents are always stopped cleanly.
+
+Errors in `createAgent` or `agentHandle.stop()` are caught and logged — they never crash the node. Similarly, transport factory failures degrade connectivity but leave the node functional locally.
+
+### API
+
+| Property / Method     | Description                                           |
+| --------------------- | ----------------------------------------------------- |
+| `node.start()`        | Begin peer discovery and role assignment              |
+| `node.stop()`         | Tear down current role and stop discovery             |
+| `node.role`           | Current role: `'hub'`, `'client'`, or `'unassigned'`  |
+| `node.io`             | IoMulti from active Server or Client                  |
+| `node.bs`             | BsMulti from active Server or Client                  |
+| `node.server`         | Server instance (when hub), else `undefined`          |
+| `node.client`         | Client instance (when client), else `undefined`       |
+| `node.socket`         | Socket to hub (when client), else `undefined`         |
+| `node.topology`       | Current network topology snapshot                     |
+| `node.on(event, cb)`  | Subscribe to `'ready'`, `'role-changed'`, `'stopped'` |
+| `node.off(event, cb)` | Unsubscribe                                           |
+
 ## Architecture Overview
 
 ### Pull-Based Reference Architecture

package/dist/README.architecture.md

@@ -77,6 +77,41 @@ In default setups you can reuse a single socket for all four channels; the code
 
 ## Core Components
 
+### 0. Node (Self-Organizing Orchestrator)
+
+The `Node` class sits above `Server` and `Client`, bridging `@rljson/network` topology events into role transitions. It:
+
+1. **Owns storage**: Creates a single `IoMem`/`BsMem` pair at `start()`, reused across all role transitions. Data survives hub↔client switches because `IoMem.close()` only flips `_isOpen` — the in-memory data is never cleared.
+2. **Reacts to topology**: Subscribes to `NetworkManager`'s `role-changed` event. On `'hub'`, tears down any Client and creates a Server. On `'client'`, tears down any Server and creates a Client.
+3. **Manages transport**: Uses injectable factories (`CreateHubTransport`/`CreateClientTransport`) to create the transport layer, keeping the Node class transport-agnostic.
+4. **Agent lifecycle**: An optional `createAgent` factory in `NodeDeps` is called on every `ready` event. The returned `AgentHandle.stop()` is called before the next role transition. This enables application-level wiring (e.g. FsAgent) without circular dependencies.
+5. **Serialized transitions**: Role transitions are queued — a new `role-changed` event waits for the previous transition to complete before starting. This prevents race conditions between teardown and setup.
+6. **Error resilience**: Errors in user-provided code (agent factories, transport factories) are caught and logged. The node continues functioning — a failed transport degrades connectivity but doesn't crash, a failed agent leaves the node's core intact.
+
+```text
+┌─────────────────────────────────────────┐
+│ Node                                    │
+│  ┌──────┐ ┌──────┐                      │
+│  │IoMem │ │BsMem │ ← owned by Node      │
+│  └──┬───┘ └──┬───┘                      │
+│     │        │                           │
+│  ┌──▼────────▼───┐  ┌────────────────┐  │
+│  │ Server/Client │──│ HubTransport   │  │
+│  │ (role-based)  │  │ or ClientSocket│  │
+│  └───────┬───────┘  └────────────────┘  │
+│          │                               │
+│  ┌───────▼───────┐                       │
+│  │ AgentHandle   │  ← optional, wired    │
+│  │ (e.g. FsAgent)│    via createAgent    │
+│  └───────────────┘                       │
+│     ▲                                    │
+│     │ role-changed                       │
+│  ┌──┴───────────┐                        │
+│  │NetworkManager│                        │
+│  └──────────────┘                        │
+└─────────────────────────────────────────┘
+```
+
 ### 1. Client
 
 The `Client` class provides a unified interface for data access by combining local storage with server storage.

package/dist/README.public.md

@@ -164,6 +164,9 @@ This is implemented with `IoMulti` and `BsMulti` internally, but the public API
 - `connector` – Connector wired to the route and socket (available when route was provided)
 - `route` – the Route passed to the constructor
 - `logger` – the `ServerLogger` instance (defaults to `noopLogger`)
+- `isConnected` – whether the socket is currently connected (tracks `disconnect`/`connect` events)
+- `onDisconnect(callback)` – registers a callback that fires when the socket disconnects (receives the reason string)
+- `onReconnect(callback)` – registers a callback that fires when the socket reconnects after a previous disconnect
 
 ### Server API
 
@@ -216,6 +219,60 @@ The same pattern is used for Bs (blob storage).
 - Peer initialization is guarded by a configurable timeout (`peerInitTimeoutMs`, default 30 s) on both server and client. On the server it prevents `addSocket()` from hanging on unresponsive clients; on the client it prevents `init()` from hanging when the server is unreachable.
 - Logging is opt-in via `{ logger }` options. Use `ConsoleLogger` for development, `BufferedLogger` for testing, `FilteredLogger` for production. Default is `NoopLogger` (zero overhead).
 
+## Reconnect handling
+
+The `Client` class tracks socket connection state and provides hooks for upper layers to react to disconnects and reconnections.
+
+### How it works
+
+Socket.IO auto-reconnects at the transport level by default. When the connection drops and is restored:
+
+1. The client-side Socket.IO socket emits `'disconnect'` then (later) `'connect'`.
+2. The `Client` class listens for these events and updates `isConnected`.
+3. Registered `onDisconnect` / `onReconnect` callbacks fire.
+4. The server auto-detects the dropped socket (`removeSocket`) and re-registers the reconnected socket via a new `'connection'` event.
+5. The server sends a bootstrap ref to the reconnected client, triggering a re-sync via the Connector's bootstrap handler.
+
+### Usage
+
+```ts
+import { Client } from '@rljson/server';
+
+const client = new Client(socket, io, bs, route, {
+  logger: new ConsoleLogger(),
+});
+await client.init();
+
+// Track connection state
+console.log(client.isConnected); // true
+
+// React to disconnects
+client.onDisconnect((reason) => {
+  console.warn(`Disconnected: ${reason}`);
+  // Pause user-facing sync indicators, queue local changes, etc.
+});
+
+// React to reconnections
+client.onReconnect(() => {
+  console.info('Reconnected to server');
+  // Resume sync, trigger re-fetch, update UI, etc.
+});
+```
+
+### What survives a reconnect
+
+| Layer             | Survives? | Details                                                           |
+| ----------------- | --------- | ----------------------------------------------------------------- |
+| Socket.IO         | ✅         | Auto-reconnects, reuses the same client-side socket object        |
+| SocketIoBridge    | ✅         | Wraps the same socket — event listeners are preserved             |
+| IoPeer / BsPeer   | ✅         | Listeners remain on the client socket; server re-creates its side |
+| Connector         | ✅         | Listeners remain; server bootstrap re-syncs state                 |
+| IoMulti / BsMulti | ✅         | Multi layers are unaffected; local Io/Bs always available         |
+
+### Cleanup
+
+All connection handlers are cleaned up automatically on `tearDown()`. After tearDown, no callbacks will fire.
+
 ## Logging
 
 Both `Server` and `Client` support structured logging via an injectable `ServerLogger` interface. Logging is opt-in — by default a zero-overhead `NoopLogger` is used.
@@ -580,6 +637,84 @@ await server.removeSocket(clientIds[0]);
 // Automatic: clients are removed when their socket emits 'disconnect'
 ```
 
+## Self-Organizing Node
+
+The `Node` class bridges `@rljson/network` peer discovery with `Server`/`Client` role transitions. Every node runs the same code — on startup it discovers peers, elects a hub, and automatically assumes the correct role.
+
+### Quick start
+
+```ts
+import { Node } from '@rljson/server';
+import { Route } from '@rljson/rljson';
+
+const node = new Node(
+  {
+    domain: 'my-app',
+    port: 3000,
+    route: Route.fromFlat('/sharedTree'),
+  },
+  {
+    createHubTransport: async (port) => { /* start HTTP+Socket.IO server */ },
+    createClientTransport: async (hubAddress) => { /* connect to hub */ },
+  },
+);
+
+await node.start();
+
+// The node auto-discovers peers and assumes a role:
+node.on('ready', ({ role, client, server, socket }) => {
+  console.log(`Role: ${role}`);          // 'hub' or 'client'
+  console.log(`Server: ${server}`);      // Server instance (hub only)
+  console.log(`Client: ${client}`);      // Client instance (client only)
+  console.log(`Socket: ${socket}`);      // Socket to hub (client only)
+});
+```
+
+### Data preservation across role transitions
+
+The `Node` owns a single `IoMem`/`BsMem` pair, created once at `start()` and reused across all role transitions. When a role changes (e.g., hub → client → hub), the underlying storage is re-initialized without losing data — `IoMem.close()` only sets `_isOpen = false`, the data in memory is preserved.
+
+This means:
+- Data written while hub survives a transition to client
+- Data written while client survives a transition to hub
+- A re-elected hub still serves all previously stored blobs and tables
+
+### Agent lifecycle
+
+The `createAgent` factory in `NodeDeps` is called on every role transition. The returned `AgentHandle.stop()` is called before the next transition or when the node stops. This is how you wire application-level agents (e.g. `FsAgent`) without creating circular dependencies:
+
+```ts
+const node = new Node(config, {
+  createHubTransport: ...,
+  createClientTransport: ...,
+  createAgent: async ({ role, client, server, socket }) => {
+    // Wire your agent here — called on every role transition
+    const stopSync = await startMySync(role, client, server);
+    return { stop: () => stopSync() };
+  },
+});
+```
+
+The Node serializes transitions — a new transition waits for the previous one to complete, ensuring agents are always stopped cleanly.
+
+Errors in `createAgent` or `agentHandle.stop()` are caught and logged — they never crash the node. Similarly, transport factory failures degrade connectivity but leave the node functional locally.
+
+### API
+
+| Property / Method     | Description                                           |
+| --------------------- | ----------------------------------------------------- |
+| `node.start()`        | Begin peer discovery and role assignment              |
+| `node.stop()`         | Tear down current role and stop discovery             |
+| `node.role`           | Current role: `'hub'`, `'client'`, or `'unassigned'`  |
+| `node.io`             | IoMulti from active Server or Client                  |
+| `node.bs`             | BsMulti from active Server or Client                  |
+| `node.server`         | Server instance (when hub), else `undefined`          |
+| `node.client`         | Client instance (when client), else `undefined`       |
+| `node.socket`         | Socket to hub (when client), else `undefined`         |
+| `node.topology`       | Current network topology snapshot                     |
+| `node.on(event, cb)`  | Subscribe to `'ready'`, `'role-changed'`, `'stopped'` |
+| `node.off(event, cb)` | Unsubscribe                                           |
+
 ## Architecture Overview
 
 ### Pull-Based Reference Architecture

package/dist/client.d.ts

@@ -45,6 +45,10 @@ export declare class Client extends BaseNode {
     private _syncConfig?;
     private _clientIdentity?;
     private _peerInitTimeoutMs;
+    private _isConnected;
+    private _disconnectCallbacks;
+    private _reconnectCallbacks;
+    private _connectionCleanup?;
     /**
      * Creates a Client instance
      * @param _socketToServer - Socket or namespace bundle to connect to server
@@ -91,11 +95,34 @@ export declare class Client extends BaseNode {
      * Returns the logger instance.
      */
     get logger(): ServerLogger;
+    /**
+     * Whether the client is currently connected to the server.
+     * Tracks socket-level connection state via `disconnect` and `connect` events.
+     */
+    get isConnected(): boolean;
+    /**
+     * Registers a callback that fires when the socket disconnects.
+     * The callback receives the disconnect reason string.
+     * @param callback - Invoked with the disconnect reason
+     */
+    onDisconnect(callback: (reason: string) => void): void;
+    /**
+     * Registers a callback that fires when the socket reconnects
+     * after a previous disconnect.
+     * @param callback - Invoked on reconnection
+     */
+    onReconnect(callback: () => void): void;
     /**
      * Creates Db and Connector from the route and IoMulti.
      * Called during init() when a route was provided.
      */
     private _setupDbAndConnector;
+    /**
+     * Registers socket-level disconnect/connect listeners.
+     * Logs state transitions and invokes registered callbacks.
+     * The `connect` callback only fires on RE-connections (not the initial connect).
+     */
+    private _registerConnectionHandlers;
     /**
      * Builds the Io multi with local and peer layers.
      */

package/dist/index.d.ts

@@ -4,8 +4,10 @@ export { FileLogger } from './file-logger.ts';
 export type { FileLoggerOptions } from './file-logger.ts';
 export { BufferedLogger, ConsoleLogger, FilteredLogger, NoopLogger, noopLogger, } from './logger.ts';
 export type { LogEntry, ServerLogger } from './logger.ts';
+export { Node } from './node.ts';
+export type { AgentHandle, CreateAgent, CreateClientTransport, CreateHubTransport, HubTransport, NodeConfig, NodeDeps, NodeEventName, NodeEvents, ReadyContext, } from './node.ts';
 export { Server } from './server.ts';
 export type { ServerOptions } from './server.ts';
 export { SocketIoBridge } from './socket-io-bridge.ts';
-export type { AckPayload, ConnectorPayload, GapFillRequest, GapFillResponse, SyncConfig, SyncEventNames, } from '@rljson/rljson';
 export { syncEvents } from '@rljson/rljson';
+export type { AckPayload, ConnectorPayload, GapFillRequest, GapFillResponse, SyncConfig, SyncEventNames, } from '@rljson/rljson';

package/dist/node.d.ts

@@ -0,0 +1,174 @@
+import { Bs } from '@rljson/bs';
+import { Io } from '@rljson/io';
+import { NetworkConfig, NetworkManagerOptions, NetworkTopology, NodeRole, RoleChangedEvent, NetworkManager } from '@rljson/network';
+import { Route } from '@rljson/rljson';
+import { Client, ClientOptions } from './client.ts';
+import { ServerLogger } from './logger.ts';
+import { Server, ServerOptions } from './server.ts';
+import { SocketLike } from './socket-bundle.ts';
+/**
+ * Transport handle returned by {@link CreateHubTransport}.
+ *
+ * Abstracts the "server side" of the transport layer so the Node class
+ * can accept incoming connections without knowing whether Socket.IO,
+ * WebSocket, or mock sockets are being used.
+ */
+export interface HubTransport {
+    /** Register a callback for incoming client connections. */
+    onConnection: (callback: (socket: SocketLike) => void) => void;
+    /** Shut down the transport (close HTTP server, etc.). */
+    close: () => Promise<void>;
+}
+/**
+ * Factory that creates a hub-side transport (e.g. HTTP + Socket.IO server).
+ * Called when this node becomes the hub.
+ */
+export type CreateHubTransport = (port: number) => Promise<HubTransport>;
+/**
+ * Factory that creates a client-side socket to connect to the hub.
+ * Called when this node becomes a client.
+ */
+export type CreateClientTransport = (hubAddress: string) => Promise<SocketLike>;
+/**
+ * Injectable dependencies for the Node class.
+ */
+export interface NodeDeps {
+    /** Factory to create hub-side transport. */
+    createHubTransport: CreateHubTransport;
+    /** Factory to create client-side socket to hub. */
+    createClientTransport: CreateClientTransport;
+    /** Options passed to NetworkManager (e.g. mock probe function). */
+    networkManagerOptions?: NetworkManagerOptions;
+    /**
+     * Optional factory for application-level agents (e.g. FsAgent).
+     * Called on every `ready` event. The returned handle's `stop()`
+     * is called before the next role transition or on `node.stop()`.
+     */
+    createAgent?: CreateAgent;
+}
+/**
+ * Configuration for a self-organizing Node.
+ */
+export interface NodeConfig {
+    /** Network domain for peer discovery. */
+    domain: string;
+    /** Port for this node's hub server / probing. */
+    port: number;
+    /** Data route for Server/Client sync. */
+    route: Route;
+    /** Full network configuration (broadcast, cloud, static, probing). */
+    network?: Partial<NetworkConfig>;
+    /** Options forwarded to the Server constructor. */
+    serverOptions?: ServerOptions;
+    /** Options forwarded to the Client constructor. */
+    clientOptions?: ClientOptions;
+    /** Logger shared across Node, Server, and Client. */
+    logger?: ServerLogger;
+    /** Directory for persistent node identity. */
+    identityDir?: string;
+}
+/**
+ * Context passed to the `ready` event and to {@link CreateAgent}.
+ */
+export interface ReadyContext {
+    /** The node's current role. */
+    role: NodeRole;
+    /** The Client instance (defined when role is `'client'`). */
+    client?: Client;
+    /** The Server instance (defined when role is `'hub'`). */
+    server?: Server;
+    /** The socket used to connect to the hub (defined when role is `'client'`). */
+    socket?: SocketLike;
+}
+/**
+ * Handle returned by {@link CreateAgent}.
+ * Node calls `stop()` before every role transition and on `node.stop()`.
+ */
+export interface AgentHandle {
+    stop: () => Promise<void> | void;
+}
+/**
+ * Factory called after each role transition to wire application-level agents
+ * (e.g. FsAgent). Return an {@link AgentHandle} whose `stop()` will be called
+ * before the next role transition or when the node stops.
+ */
+export type CreateAgent = (context: ReadyContext) => Promise<AgentHandle>;
+/** Events emitted by Node. */
+export interface NodeEvents {
+    /** Emitted when the node has assumed its role and is ready. */
+    ready: (context: ReadyContext) => void;
+    /** Emitted when the node's role changes. */
+    'role-changed': (event: RoleChangedEvent) => void;
+    /** Emitted when the node is stopped. */
+    stopped: () => void;
+}
+/** Valid event names for Node. */
+export type NodeEventName = keyof NodeEvents;
+/**
+ * Self-organizing node that automatically transitions between
+ * hub (Server) and client (Client) roles based on network topology.
+ */
+export declare class Node {
+    private readonly _config;
+    private readonly _deps;
+    private _networkManager;
+    private _server?;
+    private _client?;
+    private _hubTransport?;
+    private _clientSocket?;
+    private _agentHandle?;
+    private _ioMem?;
+    private _bsMem?;
+    private _role;
+    private _running;
+    private _transitioning?;
+    private _listeners;
+    private readonly _logger;
+    constructor(_config: NodeConfig, _deps: NodeDeps);
+    /**
+     * Start the node. Begins network discovery and role assignment.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the node. Tears down Server/Client and network discovery.
+     */
+    stop(): Promise<void>;
+    /** This node's current role. */
+    get role(): NodeRole;
+    /** Current network topology snapshot. */
+    get topology(): NetworkTopology;
+    /** The Io instance (from Server or Client), or undefined if unassigned. */
+    get io(): Io | undefined;
+    /** The Bs instance (from Server or Client), or undefined if unassigned. */
+    get bs(): Bs | undefined;
+    /** The Server instance when this node is the hub, or undefined. */
+    get server(): Server | undefined;
+    /** The Client instance when this node is a client, or undefined. */
+    get client(): Client | undefined;
+    /** The socket used to connect to the hub (defined when role is `'client'`). */
+    get socket(): SocketLike | undefined;
+    /** Whether the node is currently running. */
+    get isRunning(): boolean;
+    /** The underlying NetworkManager. */
+    get networkManager(): NetworkManager;
+    /**
+     * Subscribe to node events.
+     * @param event - Event name
+     * @param cb - Callback
+     */
+    on<E extends NodeEventName>(event: E, cb: NodeEvents[E]): void;
+    /**
+     * Unsubscribe from node events.
+     * @param event - Event name
+     * @param cb - Callback
+     */
+    off<E extends NodeEventName>(event: E, cb: NodeEvents[E]): void;
+    private _onRoleChanged;
+    private _performTransition;
+    private _becomeHub;
+    private _becomeClient;
+    private _tearDownCurrentRole;
+    private _startAgent;
+    private _stopAgent;
+    private _emit;
+}