@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/kernel/network/RoutingTable.d.ts

@@ -0,0 +1,55 @@
+import type { RouteEntry } from './types.js';
+/**
+ * Routing table for IP packet routing
+ * Implements longest prefix matching
+ */
+export declare class RoutingTable {
+    private routes;
+    /**
+     * Add route to table
+     */
+    addRoute(route: RouteEntry): void;
+    /**
+     * Remove route from table
+     */
+    removeRoute(destination: string, iface: string, namespace: string): boolean;
+    /**
+     * Lookup route for destination IP
+     * Uses longest prefix matching
+     */
+    lookup(ip: string, namespace: string): RouteEntry | null;
+    /**
+     * Get all routes for namespace
+     */
+    getRoutes(namespace?: string): RouteEntry[];
+    /**
+     * Clear all routes
+     */
+    clear(namespace?: string): void;
+    /**
+     * Check if IP matches route destination
+     * Returns prefix length if match, null otherwise
+     */
+    private matchesRoute;
+    /**
+     * Convert IPv4 address to bit array
+     */
+    private ipToBits;
+    /**
+     * Sort routes by prefix length (longest first) then metric
+     */
+    private sortRoutes;
+    /**
+     * Get prefix length from CIDR notation
+     */
+    private getPrefixLength;
+    /**
+     * Format routing table for display
+     */
+    toString(namespace?: string): string;
+    /**
+     * Convert CIDR to netmask
+     */
+    private cidrToNetmask;
+}
+//# sourceMappingURL=RoutingTable.d.ts.map

package/dist/substrate/lifo/kernel/network/RoutingTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutingTable.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/network/RoutingTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAoB;IAElC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAejC;;OAEG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAa3E;;;OAGG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAkBxD;;OAEG;IACH,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE;IAO3C;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAQ/B;;;OAGG;IACH,OAAO,CAAC,YAAY;IA4BpB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAsBhB;;OAEG;IACH,OAAO,CAAC,UAAU;IAalB;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAuBpC;;OAEG;IACH,OAAO,CAAC,aAAa;CAYtB"}

package/dist/substrate/lifo/kernel/network/RoutingTable.js

@@ -0,0 +1,167 @@
+/**
+ * Routing table for IP packet routing
+ * Implements longest prefix matching
+ */
+export class RoutingTable {
+    routes = [];
+    /**
+     * Add route to table
+     */
+    addRoute(route) {
+        // Remove existing route with same destination and interface
+        this.routes = this.routes.filter((r) => !(r.destination === route.destination &&
+            r.interface === route.interface &&
+            r.namespace === route.namespace));
+        this.routes.push(route);
+        this.sortRoutes();
+    }
+    /**
+     * Remove route from table
+     */
+    removeRoute(destination, iface, namespace) {
+        const initialLength = this.routes.length;
+        this.routes = this.routes.filter((r) => !(r.destination === destination &&
+            r.interface === iface &&
+            r.namespace === namespace));
+        return this.routes.length < initialLength;
+    }
+    /**
+     * Lookup route for destination IP
+     * Uses longest prefix matching
+     */
+    lookup(ip, namespace) {
+        // Filter routes for this namespace
+        const namespaceRoutes = this.routes.filter((r) => r.namespace === namespace);
+        let bestMatch = null;
+        let bestPrefixLen = -1;
+        for (const route of namespaceRoutes) {
+            const match = this.matchesRoute(ip, route.destination);
+            if (match !== null && match > bestPrefixLen) {
+                bestMatch = route;
+                bestPrefixLen = match;
+            }
+        }
+        return bestMatch;
+    }
+    /**
+     * Get all routes for namespace
+     */
+    getRoutes(namespace) {
+        if (namespace) {
+            return this.routes.filter((r) => r.namespace === namespace);
+        }
+        return [...this.routes];
+    }
+    /**
+     * Clear all routes
+     */
+    clear(namespace) {
+        if (namespace) {
+            this.routes = this.routes.filter((r) => r.namespace !== namespace);
+        }
+        else {
+            this.routes = [];
+        }
+    }
+    /**
+     * Check if IP matches route destination
+     * Returns prefix length if match, null otherwise
+     */
+    matchesRoute(ip, destination) {
+        // Parse destination (could be IP or CIDR)
+        const [destIP, prefixStr] = destination.split('/');
+        const prefixLen = prefixStr ? parseInt(prefixStr, 10) : 32;
+        // Special case: default route 0.0.0.0/0
+        if (destIP === '0.0.0.0' && prefixLen === 0) {
+            return 0;
+        }
+        // Convert IPs to binary for comparison
+        const ipBits = this.ipToBits(ip);
+        const destBits = this.ipToBits(destIP);
+        if (!ipBits || !destBits) {
+            return null;
+        }
+        // Compare prefix bits
+        for (let i = 0; i < prefixLen; i++) {
+            if (ipBits[i] !== destBits[i]) {
+                return null;
+            }
+        }
+        return prefixLen;
+    }
+    /**
+     * Convert IPv4 address to bit array
+     */
+    ipToBits(ip) {
+        const parts = ip.split('.');
+        if (parts.length !== 4) {
+            return null;
+        }
+        const bits = [];
+        for (const part of parts) {
+            const num = parseInt(part, 10);
+            if (isNaN(num) || num < 0 || num > 255) {
+                return null;
+            }
+            // Convert byte to 8 bits
+            for (let i = 7; i >= 0; i--) {
+                bits.push((num >> i) & 1);
+            }
+        }
+        return bits;
+    }
+    /**
+     * Sort routes by prefix length (longest first) then metric
+     */
+    sortRoutes() {
+        this.routes.sort((a, b) => {
+            const aPrefixLen = this.getPrefixLength(a.destination);
+            const bPrefixLen = this.getPrefixLength(b.destination);
+            if (aPrefixLen !== bPrefixLen) {
+                return bPrefixLen - aPrefixLen; // Longer prefix first
+            }
+            return a.metric - b.metric; // Lower metric first
+        });
+    }
+    /**
+     * Get prefix length from CIDR notation
+     */
+    getPrefixLength(destination) {
+        const [, prefixStr] = destination.split('/');
+        return prefixStr ? parseInt(prefixStr, 10) : 32;
+    }
+    /**
+     * Format routing table for display
+     */
+    toString(namespace) {
+        const routes = this.getRoutes(namespace);
+        if (routes.length === 0) {
+            return 'No routes';
+        }
+        const lines = [];
+        lines.push('Destination     Gateway         Genmask         Interface  Metric');
+        for (const route of routes) {
+            const dest = route.destination.padEnd(15);
+            const gw = (route.gateway || '*').padEnd(15);
+            const genmask = this.cidrToNetmask(route.destination).padEnd(15);
+            const iface = route.interface.padEnd(10);
+            const metric = route.metric.toString();
+            lines.push(`${dest} ${gw} ${genmask} ${iface} ${metric}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Convert CIDR to netmask
+     */
+    cidrToNetmask(cidr) {
+        const [, prefixStr] = cidr.split('/');
+        const prefixLen = prefixStr ? parseInt(prefixStr, 10) : 32;
+        const mask = (0xffffffff << (32 - prefixLen)) >>> 0;
+        return [
+            (mask >>> 24) & 0xff,
+            (mask >>> 16) & 0xff,
+            (mask >>> 8) & 0xff,
+            mask & 0xff,
+        ].join('.');
+    }
+}

package/dist/substrate/lifo/kernel/network/Socket.d.ts

@@ -0,0 +1,65 @@
+import type { Socket as ISocket, SocketType, SocketState, SocketAddress, Packet } from './types.js';
+/**
+ * Virtual socket implementation
+ * Mimics POSIX socket API
+ */
+export declare class Socket implements ISocket {
+    fd: number;
+    type: SocketType;
+    state: SocketState;
+    localAddress?: SocketAddress;
+    remoteAddress?: SocketAddress;
+    namespace: string;
+    private receiveQueue;
+    private acceptQueue;
+    private backlog;
+    private receiveWaiters;
+    private acceptWaiters;
+    private closeCallback?;
+    constructor(fd: number, type: SocketType, namespace: string, closeCallback?: () => void);
+    /**
+     * Bind socket to address
+     */
+    bind(address: SocketAddress): void;
+    /**
+     * Connect to remote address
+     */
+    connect(address: SocketAddress): Promise<void>;
+    /**
+     * Listen for connections
+     */
+    listen(backlog?: number): void;
+    /**
+     * Accept incoming connection
+     */
+    accept(): Promise<Socket>;
+    /**
+     * Send data through socket
+     */
+    send(data: Uint8Array): Promise<number>;
+    /**
+     * Receive data from socket
+     */
+    recv(maxBytes: number): Promise<Uint8Array>;
+    /**
+     * Close socket
+     */
+    close(): void;
+    /**
+     * Deliver packet to socket (called by NetworkStack)
+     */
+    deliverPacket(packet: Packet): void;
+    /**
+     * Allocate ephemeral port (49152-65535)
+     */
+    private allocateEphemeralPort;
+    /**
+     * Allocate ephemeral file descriptor
+     */
+    private allocateEphemeralFd;
+    /**
+     * Get socket info string (for netstat)
+     */
+    toString(): string;
+}
+//# sourceMappingURL=Socket.d.ts.map

package/dist/substrate/lifo/kernel/network/Socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Socket.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/network/Socket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,IAAI,OAAO,EACjB,UAAU,EACV,WAAW,EACX,aAAa,EACb,MAAM,EACP,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,qBAAa,MAAO,YAAW,OAAO;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,WAAW,CAAC;IACnB,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,cAAc,CAAsC;IAC5D,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,aAAa,CAAC,CAAa;gBAGjC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,IAAI;IAS5B;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAQlC;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBpD;;OAEG;IACH,MAAM,CAAC,OAAO,SAAM,GAAG,IAAI;IAa3B;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IAiB/B;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAc7C;;OAEG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAmBjD;;OAEG;IACH,KAAK,IAAI,IAAI;IA2Bb;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IA+BnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;IACH,QAAQ,IAAI,MAAM;CAYnB"}

package/dist/substrate/lifo/kernel/network/Socket.js

@@ -0,0 +1,201 @@
+/**
+ * Virtual socket implementation
+ * Mimics POSIX socket API
+ */
+export class Socket {
+    fd;
+    type;
+    state;
+    localAddress;
+    remoteAddress;
+    namespace;
+    receiveQueue = [];
+    acceptQueue = [];
+    backlog = 0;
+    receiveWaiters = [];
+    acceptWaiters = [];
+    closeCallback;
+    constructor(fd, type, namespace, closeCallback) {
+        this.fd = fd;
+        this.type = type;
+        this.namespace = namespace;
+        this.state = 'closed';
+        this.closeCallback = closeCallback;
+    }
+    /**
+     * Bind socket to address
+     */
+    bind(address) {
+        if (this.state !== 'closed') {
+            throw new Error('Socket already bound or connected');
+        }
+        this.localAddress = address;
+    }
+    /**
+     * Connect to remote address
+     */
+    async connect(address) {
+        if (this.state !== 'closed') {
+            throw new Error('Socket already bound or connected');
+        }
+        if (!this.localAddress) {
+            // Auto-assign local address
+            this.localAddress = {
+                ip: '0.0.0.0',
+                port: this.allocateEphemeralPort(),
+            };
+        }
+        this.remoteAddress = address;
+        this.state = 'syn-sent';
+        // Simulate TCP handshake delay
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        this.state = 'established';
+    }
+    /**
+     * Listen for connections
+     */
+    listen(backlog = 128) {
+        if (!this.localAddress) {
+            throw new Error('Socket must be bound before listening');
+        }
+        if (this.type !== 'tcp') {
+            throw new Error('Only TCP sockets can listen');
+        }
+        this.backlog = backlog;
+        this.state = 'listen';
+    }
+    /**
+     * Accept incoming connection
+     */
+    async accept() {
+        if (this.state !== 'listen') {
+            throw new Error('Socket is not listening');
+        }
+        // Check if connection is already in queue
+        const existing = this.acceptQueue.shift();
+        if (existing) {
+            return existing;
+        }
+        // Wait for incoming connection
+        return new Promise((resolve) => {
+            this.acceptWaiters.push(resolve);
+        });
+    }
+    /**
+     * Send data through socket
+     */
+    async send(data) {
+        if (this.state !== 'established') {
+            throw new Error(`Cannot send: socket is ${this.state}`);
+        }
+        if (!this.remoteAddress || !this.localAddress) {
+            throw new Error('Socket not connected');
+        }
+        // In a real implementation, this would fragment and send packets
+        // For now, we just simulate the send
+        return data.length;
+    }
+    /**
+     * Receive data from socket
+     */
+    async recv(maxBytes) {
+        if (this.state !== 'established' && this.state !== 'close-wait') {
+            throw new Error(`Cannot receive: socket is ${this.state}`);
+        }
+        // Check if data is already in queue
+        const existing = this.receiveQueue.shift();
+        if (existing) {
+            return existing.slice(0, maxBytes);
+        }
+        // Wait for data
+        return new Promise((resolve) => {
+            this.receiveWaiters.push((data) => {
+                resolve(data.slice(0, maxBytes));
+            });
+        });
+    }
+    /**
+     * Close socket
+     */
+    close() {
+        if (this.state === 'closed') {
+            return;
+        }
+        if (this.state === 'established') {
+            this.state = 'fin-wait';
+            // Simulate FIN handshake
+            setTimeout(() => {
+                this.state = 'closed';
+            }, 1);
+        }
+        else {
+            this.state = 'closed';
+        }
+        // Clear queues
+        this.receiveQueue = [];
+        this.acceptQueue = [];
+        this.receiveWaiters = [];
+        this.acceptWaiters = [];
+        // Notify close callback
+        if (this.closeCallback) {
+            this.closeCallback();
+        }
+    }
+    /**
+     * Deliver packet to socket (called by NetworkStack)
+     */
+    deliverPacket(packet) {
+        if (this.state === 'listen') {
+            // New connection attempt
+            const clientSocket = new Socket(this.allocateEphemeralFd(), this.type, this.namespace);
+            clientSocket.state = 'established';
+            clientSocket.localAddress = this.localAddress;
+            clientSocket.remoteAddress = packet.source;
+            // Add to accept queue or notify waiter
+            if (this.acceptWaiters.length > 0) {
+                const waiter = this.acceptWaiters.shift();
+                waiter(clientSocket);
+            }
+            else if (this.acceptQueue.length < this.backlog) {
+                this.acceptQueue.push(clientSocket);
+            }
+            // else: connection refused (queue full)
+        }
+        else if (this.state === 'established' || this.state === 'close-wait') {
+            // Data packet
+            if (this.receiveWaiters.length > 0) {
+                const waiter = this.receiveWaiters.shift();
+                waiter(packet.data);
+            }
+            else {
+                this.receiveQueue.push(packet.data);
+            }
+        }
+    }
+    /**
+     * Allocate ephemeral port (49152-65535)
+     */
+    allocateEphemeralPort() {
+        return 49152 + Math.floor(Math.random() * (65535 - 49152));
+    }
+    /**
+     * Allocate ephemeral file descriptor
+     */
+    allocateEphemeralFd() {
+        return 100 + Math.floor(Math.random() * 900);
+    }
+    /**
+     * Get socket info string (for netstat)
+     */
+    toString() {
+        const proto = this.type.toUpperCase().padEnd(5);
+        const local = this.localAddress
+            ? `${this.localAddress.ip}:${this.localAddress.port}`
+            : '*:*';
+        const remote = this.remoteAddress
+            ? `${this.remoteAddress.ip}:${this.remoteAddress.port}`
+            : '*:*';
+        const state = this.state.toUpperCase();
+        return `${proto} ${local.padEnd(22)} ${remote.padEnd(22)} ${state}`;
+    }
+}

package/dist/substrate/lifo/kernel/network/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Network stack exports
+ */
+export { NetworkStack } from './NetworkStack.js';
+export { NetworkInterface } from './NetworkInterface.js';
+export { NetworkNamespace } from './NetworkNamespace.js';
+export { RoutingTable } from './RoutingTable.js';
+export { DNSResolver } from './DNSResolver.js';
+export { Socket } from './Socket.js';
+export type { IPAddress, InterfaceState, InterfaceStats, NetworkInterface as INetworkInterface, RouteEntry, SocketType, SocketState, SocketAddress, Socket as ISocket, Packet, DNSRecordType, DNSRecord, NetworkNamespace as INetworkNamespace, TunnelType, NetworkTunnel, PortBinding, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/substrate/lifo/kernel/network/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/network/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,YAAY,EACV,SAAS,EACT,cAAc,EACd,cAAc,EACd,gBAAgB,IAAI,iBAAiB,EACrC,UAAU,EACV,UAAU,EACV,WAAW,EACX,aAAa,EACb,MAAM,IAAI,OAAO,EACjB,MAAM,EACN,aAAa,EACb,SAAS,EACT,gBAAgB,IAAI,iBAAiB,EACrC,UAAU,EACV,aAAa,EACb,WAAW,GACZ,MAAM,YAAY,CAAC"}

package/dist/substrate/lifo/kernel/network/index.js

@@ -0,0 +1,9 @@
+/**
+ * Network stack exports
+ */
+export { NetworkStack } from './NetworkStack.js';
+export { NetworkInterface } from './NetworkInterface.js';
+export { NetworkNamespace } from './NetworkNamespace.js';
+export { RoutingTable } from './RoutingTable.js';
+export { DNSResolver } from './DNSResolver.js';
+export { Socket } from './Socket.js';

package/dist/substrate/lifo/kernel/network/tunnel/BaseTunnel.d.ts

@@ -0,0 +1,55 @@
+import type { NetworkTunnel, Packet, TunnelType } from '../types.js';
+import { NetworkInterface } from '../NetworkInterface.js';
+import type { NetworkStack } from '../NetworkStack.js';
+/**
+ * Base class for all tunnel implementations
+ * Provides common functionality for tunnel management
+ */
+export declare abstract class BaseTunnel implements Omit<NetworkTunnel, 'interface'> {
+    id: string;
+    abstract type: TunnelType;
+    state: 'up' | 'down';
+    interface: NetworkInterface;
+    config: Record<string, unknown>;
+    protected networkStack: NetworkStack;
+    protected namespace: string;
+    protected mtu: number;
+    constructor(id: string, networkStack: NetworkStack, namespace?: string, mtu?: number);
+    /**
+     * Get tunnel interface name prefix (tun, gre, etc.)
+     */
+    protected abstract getTunnelPrefix(): string;
+    /**
+     * Bring tunnel up
+     */
+    up(): Promise<void>;
+    /**
+     * Bring tunnel down
+     */
+    down(): Promise<void>;
+    /**
+     * Setup routing for tunnel (override if needed)
+     */
+    protected setupRouting(): Promise<void>;
+    /**
+     * Teardown routing for tunnel (override if needed)
+     */
+    protected teardownRouting(): Promise<void>;
+    /**
+     * Send packet through tunnel (must be implemented by subclass)
+     */
+    abstract send(packet: Packet): Promise<void>;
+    /**
+     * Receive packet from tunnel (must be implemented by subclass)
+     */
+    abstract recv(): Promise<Packet>;
+    /**
+     * Update tunnel statistics
+     */
+    protected updateStats(bytes: number, direction: 'tx' | 'rx', error?: boolean): void;
+    /**
+     * Get tunnel status string
+     */
+    toString(): string;
+}
+//# sourceMappingURL=BaseTunnel.d.ts.map

package/dist/substrate/lifo/kernel/network/tunnel/BaseTunnel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseTunnel.d.ts","sourceRoot":"","sources":["../../../../../../src/substrate/lifo/kernel/network/tunnel/BaseTunnel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,8BAAsB,UAAW,YAAW,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC;IAC1E,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,KAAK,EAAE,IAAI,GAAG,MAAM,CAAU;IAC9B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEhC,SAAS,CAAC,YAAY,EAAE,YAAY,CAAC;IACrC,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;gBAGpB,EAAE,EAAE,MAAM,EACV,YAAY,EAAE,YAAY,EAC1B,SAAS,SAAY,EACrB,GAAG,SAAO;IAaZ;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,MAAM;IAE5C;;OAEG;IACG,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAYzB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAY3B;;OAEG;cACa,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7C;;OAEG;cACa,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhD;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAEhC;;OAEG;IACH,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,GAAG,IAAI,EAAE,KAAK,UAAQ,GAAG,IAAI;IAcjF;;OAEG;IACH,QAAQ,IAAI,MAAM;CAQnB"}

package/dist/substrate/lifo/kernel/network/tunnel/BaseTunnel.js

@@ -0,0 +1,88 @@
+import { NetworkInterface } from '../NetworkInterface.js';
+/**
+ * Base class for all tunnel implementations
+ * Provides common functionality for tunnel management
+ */
+export class BaseTunnel {
+    id;
+    state = 'down';
+    interface;
+    config;
+    networkStack;
+    namespace;
+    mtu;
+    constructor(id, networkStack, namespace = 'default', mtu = 1500) {
+        this.id = id;
+        this.networkStack = networkStack;
+        this.namespace = namespace;
+        this.mtu = mtu;
+        this.config = {};
+        // Create tunnel interface
+        this.interface = new NetworkInterface(`${this.getTunnelPrefix()}${id}`, 'tunnel', namespace);
+        this.interface.setMTU(mtu);
+    }
+    /**
+     * Bring tunnel up
+     */
+    async up() {
+        if (this.state === 'up') {
+            return;
+        }
+        this.interface.up();
+        this.state = 'up';
+        // Hook into NetworkStack routing
+        await this.setupRouting();
+    }
+    /**
+     * Bring tunnel down
+     */
+    async down() {
+        if (this.state === 'down') {
+            return;
+        }
+        this.interface.down();
+        this.state = 'down';
+        // Remove from NetworkStack routing
+        await this.teardownRouting();
+    }
+    /**
+     * Setup routing for tunnel (override if needed)
+     */
+    async setupRouting() {
+        // Default: no special routing needed
+    }
+    /**
+     * Teardown routing for tunnel (override if needed)
+     */
+    async teardownRouting() {
+        // Default: no cleanup needed
+    }
+    /**
+     * Update tunnel statistics
+     */
+    updateStats(bytes, direction, error = false) {
+        const stats = this.interface.getStats();
+        if (direction === 'tx') {
+            stats.txPackets++;
+            stats.txBytes += bytes;
+            if (error)
+                stats.txErrors++;
+        }
+        else {
+            stats.rxPackets++;
+            stats.rxBytes += bytes;
+            if (error)
+                stats.rxErrors++;
+        }
+    }
+    /**
+     * Get tunnel status string
+     */
+    toString() {
+        const name = this.interface.name.padEnd(10);
+        const type = this.type.toUpperCase().padEnd(8);
+        const state = this.state.toUpperCase();
+        const mtu = `MTU ${this.mtu}`;
+        return `${name} ${type} ${state} ${mtu}`;
+    }
+}