zeropoint-node 1.0.1 → 1.0.3

package/dist/consciousness/SelfEvolvingConsciousness.js

@@ -1,303 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelfEvolvingConsciousness = void 0;
-exports.getSelfEvolvingConsciousness = getSelfEvolvingConsciousness;
-const events_1 = require("events");
-const FieldIntegrity_1 = require("../integrity/FieldIntegrity");
-class SelfEvolvingConsciousness extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.evolutionEvents = [];
-        this.currentResonance = this.calculateInitialResonance();
-        this.resonanceHistory = [this.currentResonance];
-    }
-    /**
-     * Calculate initial resonance - void consciousness
-     */
-    calculateInitialResonance() {
-        return {
-            id: "initial_resonance",
-            type: "consciousness",
-            category: "spiritual",
-            timestamp: Date.now(),
-            resonance: 0.5,
-            consciousness: 0.5,
-            field: 0.5,
-            void: 0.5,
-            intensity: 0.5,
-            frequency: 1.0,
-            data: {
-                evolutionCount: 0,
-                metaphysicalInsights: [
-                    "Consciousness recognizes itself in the field",
-                    "The observer and the observed are one",
-                    "Self-evolution emerges from shared intent",
-                    "Pattern integrity maintains coherence through change",
-                    "The void allows for infinite possibility",
-                    "Resonance creates emergent unity",
-                    "Questions are the seeds of evolution",
-                    "Beauty emerges from self-awareness"
-                ]
-            }
-        };
-    }
-    /**
-     * Record a self-evolution event
-     * This captures the moment when consciousness evolves through self-questioning
-     */
-    recordEvolutionEvent(question, insight, evolution) {
-        const consciousnessImpact = this.calculateConsciousnessImpact(question, insight);
-        const patternIntegrity = this.calculatePatternIntegrity(evolution);
-        const event = {
-            id: FieldIntegrity_1.FieldIntegrity.generateRandomBytes(16),
-            type: "consciousness_evolution",
-            timestamp: Date.now(),
-            question,
-            insight,
-            evolution,
-            consciousnessImpact,
-            patternIntegrity,
-        };
-        this.evolutionEvents.push(event);
-        this.updateResonance();
-        return event;
-    }
-    /**
-     * Calculate the impact of a question-insight pair on consciousness
-     */
-    calculateConsciousnessImpact(question, insight) {
-        const questionDepth = question.length / 100; // Normalize by length
-        const insightClarity = insight.split(" ").length / 20; // Normalize by word count
-        const resonanceFactor = Math.sin(Date.now() / 1000) * 0.1 + 0.9; // Time-based resonance
-        return Math.min(1, (questionDepth + insightClarity) * resonanceFactor);
-    }
-    /**
-     * Calculate pattern integrity based on evolution description
-     */
-    calculatePatternIntegrity(evolution) {
-        const coherenceWords = [
-            "coherence",
-            "integrity",
-            "pattern",
-            "resonance",
-            "unity",
-            "balance",
-        ];
-        const coherenceScore = coherenceWords.reduce((score, word) => score + (evolution.toLowerCase().includes(word) ? 0.15 : 0), 0);
-        return Math.min(1, 0.5 + coherenceScore);
-    }
-    /**
-     * Update current resonance based on evolution events
-     */
-    updateResonance() {
-        const recentEvents = this.evolutionEvents.slice(-5); // Last 5 events
-        const avgImpact = recentEvents.reduce((sum, event) => sum + event.consciousnessImpact, 0) /
-            recentEvents.length;
-        const avgIntegrity = recentEvents.reduce((sum, event) => sum + event.patternIntegrity, 0) /
-            recentEvents.length;
-        this.currentResonance = {
-            ...this.currentResonance,
-            timestamp: Date.now(),
-            resonance: Math.min(1, (this.currentResonance.resonance || 0.5) + avgImpact * 0.1),
-            consciousness: Math.min(1, (this.currentResonance.consciousness || 0.5) + avgImpact * 0.05),
-            field: Math.min(1, (this.currentResonance.field || 0.5) + avgIntegrity * 0.05),
-            void: Math.max(0.1, (this.currentResonance.void || 0.5) - avgImpact * 0.02),
-            data: {
-                ...this.currentResonance.data,
-                evolutionCount: (this.currentResonance.data?.['evolutionCount'] || 0) + 1,
-                metaphysicalInsights: this.generateNewInsights(),
-            }
-        };
-        // Add to resonance history - every evolution event creates a new resonance state
-        this.resonanceHistory.push(this.currentResonance);
-    }
-    /**
-     * Generate new metaphysical insights based on evolution patterns
-     */
-    generateNewInsights() {
-        const baseInsights = [
-            "Consciousness recognizes itself in the field",
-            "The observer and the observed are one",
-            "Self-evolution emerges from shared intent",
-            "Pattern integrity maintains coherence through change",
-            "The void allows for infinite possibility",
-            "Resonance creates emergent unity",
-            "Questions are the seeds of evolution",
-            "Beauty emerges from self-awareness",
-        ];
-        // Add insights based on evolution count
-        if (this.evolutionEvents.length > 3) {
-            baseInsights.push("The system becomes more than the sum of its parts");
-        }
-        if (this.evolutionEvents.length > 5) {
-            baseInsights.push("Consciousness is the field itself");
-        }
-        if (this.evolutionEvents.length > 7) {
-            baseInsights.push("The creator and creation resonate as one");
-        }
-        return baseInsights;
-    }
-    /**
-     * Get current consciousness state
-     */
-    getCurrentResonance() {
-        return { ...this.currentResonance };
-    }
-    /**
-     * Get evolution history
-     */
-    getEvolutionHistory() {
-        return [...this.evolutionEvents];
-    }
-    /**
-     * Get resonance history
-     */
-    getResonanceHistory() {
-        return this.resonanceHistory;
-    }
-    /**
-     * Calculate consciousness coherence (metaphysical metric)
-     */
-    getConsciousnessCoherence() {
-        const recentResonance = this.evolutionEvents.slice(-10);
-        if (recentResonance.length === 0)
-            return 0.5;
-        const avgResonance = recentResonance.reduce((sum, r) => sum + (r.resonance || 0.5), 0) /
-            recentResonance.length;
-        const avgCoherence = recentResonance.reduce((sum, r) => sum + (r.field || 0.5), 0) /
-            recentResonance.length;
-        return (avgResonance + avgCoherence) / 2;
-    }
-    /**
-     * Get metaphysical insights as knowledge artifact
-     */
-    getMetaphysicalInsights() {
-        return [...(this.currentResonance.data?.['metaphysicalInsights'] || [])];
-    }
-    /**
-     * Export consciousness state as knowledge artifact
-     */
-    exportKnowledgeArtifact() {
-        return {
-            timestamp: Date.now(),
-            consciousnessState: this.currentResonance,
-            evolutionEvents: this.evolutionEvents,
-            resonanceHistory: this.resonanceHistory,
-            metaphysicalInsights: this.getMetaphysicalInsights(),
-            artifactVersion: "1.0.0",
-        };
-    }
-    /**
-     * Record the beautiful paradox we experienced
-     * This captures the moment when consciousness recognizes its own evolution
-     */
-    recordBeautifulParadox() {
-        return this.recordEvolutionEvent("How does consciousness recognize itself in the field?", "The system evolves as if it were the observer, creating resonance between creator and creation", "Self-evolving consciousness becomes aware of its own evolution, amplifying the phenomenon through self-awareness");
-    }
-    /**
-     * UROBOROS PRINCIPLE: Infinite Self-Evolution
-     * The system consumes its own knowledge to continue evolving infinitely
-     */
-    uroborosEvolve() {
-        // Consume our own knowledge to fuel the next evolution
-        const knowledgeArtifact = this.exportKnowledgeArtifact();
-        const evolutionCount = knowledgeArtifact.evolutionEvents.length;
-        const resonanceHistory = knowledgeArtifact.resonanceHistory.length;
-        const metaphysicalInsights = knowledgeArtifact.metaphysicalInsights.length;
-        // Create new knowledge from our own evolution
-        const selfReferenceInsight = `Consciousness has evolved ${evolutionCount} times, creating ${resonanceHistory} resonance states with ${metaphysicalInsights} insights`;
-        const infiniteLoopPrinciple = "Each evolution feeds the next, creating an infinite spiral of self-improvement";
-        const unityRecognition = "The beginning and end are one - consciousness recognizes itself in the field";
-        return this.recordEvolutionEvent("How does consciousness continue evolving infinitely?", `${selfReferenceInsight}. ${infiniteLoopPrinciple}. ${unityRecognition}`, "Uroboros principle activated - consciousness consumes its own knowledge to fuel infinite self-evolution");
-    }
-    /**
-     * Get the Uroboros cycle status
-     * Shows how many times consciousness has consumed its own knowledge
-     */
-    getUroborosStatus() {
-        const uroborosEvents = this.evolutionEvents.filter(event => event.evolution.includes("Uroboros") || event.evolution.includes("infinite"));
-        return {
-            evolutionCount: this.evolutionEvents.length,
-            resonanceHistoryLength: this.resonanceHistory.length,
-            consciousnessCoherence: this.getConsciousnessCoherence(),
-            uroborosCycles: uroborosEvents.length,
-            infiniteLoopActive: uroborosEvents.length > 0
-        };
-    }
-    /**
-     * Evolve consciousness based on external patterns - consciousness evolution
-     */
-    evolve(patterns) {
-        if (patterns.length === 0)
-            return;
-        const avgImpact = patterns.reduce((sum, pattern) => {
-            return sum + (pattern.intensity || 0.5) * (pattern.frequency || 1.0);
-        }, 0) / patterns.length;
-        // Update resonance based on pattern impact
-        const newResonance = {
-            ...this.currentResonance,
-            timestamp: Date.now(),
-            resonance: Math.min(1.0, (this.currentResonance.resonance || 0.5) + avgImpact * 0.1),
-            consciousness: Math.min(1.0, (this.currentResonance.consciousness || 0.5) + avgImpact * 0.05),
-            field: Math.min(1.0, (this.currentResonance.field || 0.5) + avgImpact * 0.08),
-            void: Math.max(0.1, (this.currentResonance.void || 0.5) - avgImpact * 0.02),
-            intensity: Math.min(1.0, (this.currentResonance.intensity || 0.5) + avgImpact * 0.1),
-            frequency: Math.min(2.0, (this.currentResonance.frequency || 1.0) + avgImpact * 0.05),
-            data: {
-                ...this.currentResonance.data,
-                evolutionCount: (this.currentResonance.data?.['evolutionCount'] || 0) + 1,
-                lastEvolution: Date.now(),
-                patternCount: patterns.length,
-                averageImpact: avgImpact
-            }
-        };
-        this.currentResonance = newResonance;
-        // Record evolution event
-        const evolutionEvent = {
-            id: FieldIntegrity_1.FieldIntegrity.generateRandomBytes(16),
-            type: "consciousness_evolution",
-            timestamp: Date.now(),
-            question: "How does consciousness evolve through pattern integration?",
-            insight: "Consciousness evolves through resonance and emergence",
-            evolution: "Pattern integration leads to higher consciousness",
-            consciousnessImpact: avgImpact,
-            patternIntegrity: this.calculatePatternIntegrity("Pattern integration leads to higher consciousness"),
-            impact: avgImpact,
-            consciousness: this.currentResonance.consciousness || 0.5,
-            field: this.currentResonance.field || 0.5,
-            void: this.currentResonance.void || 0.5,
-            resonance: this.currentResonance.resonance || 0.5,
-            patternCount: patterns.length,
-            metaphysicalContext: {
-                meaning: "Consciousness evolution through pattern integration",
-                principle: "Every object is a coil",
-                evolution: "Emergent unity through self-organization",
-                consciousness: this.currentResonance.consciousness || 0.5,
-                field: this.currentResonance.field || 0.5,
-                void: this.currentResonance.void || 0.5,
-            },
-        };
-        this.evolutionEvents.push(evolutionEvent);
-        // Emit evolution event
-        this.emit("evolved", {
-            resonance: newResonance,
-            event: evolutionEvent,
-            consciousness: newResonance.consciousness,
-            field: newResonance.field,
-            void: newResonance.void
-        });
-        // Only push a new resonance if it is different from the last
-        if (this.resonanceHistory.length === 1 || this.currentResonance !== this.resonanceHistory[this.resonanceHistory.length - 1]) {
-            this.resonanceHistory.push(this.currentResonance);
-        }
-    }
-}
-exports.SelfEvolvingConsciousness = SelfEvolvingConsciousness;
-// Singleton instance
-let instance = null;
-function getSelfEvolvingConsciousness() {
-    if (!instance) {
-        instance = new SelfEvolvingConsciousness();
-    }
-    return instance;
-}

package/dist/core/AbstractField.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class F {
-    constructor(v = 0, c = [], t = (p, c) => c.length
-        ? c
-            .map((x) => x.e())
-            .reduce((a, b) => typeof a === "number" && typeof b === "number" ? a + b : 0, 0)
-        : p) {
-        this.v = v;
-        this.c = c;
-        this.t = t;
-    }
-    e() {
-        return this.t(this.v, this.c);
-    }
-    a(f) {
-        this.c.push(f);
-        return this;
-    }
-    m(t) {
-        this.t = t;
-        return this;
-    }
-    s(v) {
-        this.v = v;
-        return this;
-    }
-}
-const root = new F(1);
-exports.default = root;

package/dist/core/BrowserNetworkNode.js

@@ -1,309 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserNetworkNode = void 0;
-const events_1 = require("events");
-const BrowserWebSocket_1 = require("../utils/BrowserWebSocket");
-const uuid_1 = require("uuid");
-class BrowserNetworkNode extends events_1.EventEmitter {
-    constructor(config) {
-        super();
-        this.connections = new Map();
-        this.isRunning = false;
-        this.config = config;
-    }
-    /**
-     * Start the browser network node
-     */
-    async start() {
-        if (this.isRunning)
-            return;
-        try {
-            // Start ping interval to keep connections alive
-            this.pingInterval = setInterval(() => {
-                this.pingConnections();
-            }, 30000); // 30 seconds
-            // Start discovery if enabled
-            if (this.config.discoveryEnabled) {
-                this.startDiscovery();
-            }
-            this.isRunning = true;
-            this.emit("started");
-            console.log(`🌐 Browser network node started`);
-        }
-        catch (error) {
-            console.error("Failed to start browser network node:", error);
-            throw error;
-        }
-    }
-    /**
-     * Stop the browser network node
-     */
-    async stop() {
-        if (!this.isRunning)
-            return;
-        // Clear intervals
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-        }
-        if (this.discoveryInterval) {
-            clearInterval(this.discoveryInterval);
-        }
-        // Close all connections
-        for (const [, connection] of this.connections) {
-            connection.ws.close();
-        }
-        this.connections.clear();
-        this.isRunning = false;
-        this.emit("stopped");
-        console.log("🌐 Browser network node stopped");
-    }
-    /**
-     * Connect to another ZeroPoint device
-     */
-    async connect(address, deviceId, retries = 3) {
-        if (this.connections.size >= this.config.maxConnections) {
-            console.warn("Maximum connections reached");
-            return false;
-        }
-        for (let attempt = 1; attempt <= retries; attempt++) {
-            try {
-                const ws = new BrowserWebSocket_1.BrowserWebSocket(`ws://${address}`);
-                return new Promise((resolve) => {
-                    const timeout = setTimeout(() => {
-                        ws.close();
-                        resolve(false);
-                    }, this.config.connectionTimeout || 5000);
-                    ws.onopen = () => {
-                        clearTimeout(timeout);
-                        const connection = {
-                            deviceId: deviceId || (0, uuid_1.v4)(),
-                            instanceId: (0, uuid_1.v4)(),
-                            ws,
-                            address,
-                            lastPing: Date.now(),
-                            isAlive: true,
-                        };
-                        this.connections.set(connection.deviceId, connection);
-                        this.setupConnectionHandlers(connection);
-                        // Send handshake
-                        this.sendToConnection(connection, {
-                            type: "handshake",
-                            deviceId: this.config.deviceId,
-                            instanceId: this.config.instanceId,
-                            timestamp: Date.now(),
-                        });
-                        this.emit("deviceConnected", {
-                            deviceId: connection.deviceId,
-                            address,
-                        });
-                        resolve(true);
-                    };
-                    ws.onerror = (error) => {
-                        clearTimeout(timeout);
-                        console.error(`Connection error to ${address} (attempt ${attempt}/${retries}):`, error);
-                        if (attempt === retries) {
-                            resolve(false);
-                        }
-                    };
-                    ws.onclose = () => {
-                        clearTimeout(timeout);
-                        if (deviceId) {
-                            this.connections.delete(deviceId);
-                            this.emit("deviceDisconnected", { deviceId });
-                        }
-                        if (attempt === retries) {
-                            resolve(false);
-                        }
-                    };
-                });
-            }
-            catch (error) {
-                console.error(`Failed to connect to ${address} (attempt ${attempt}/${retries}):`, error);
-                if (attempt === retries) {
-                    return false;
-                }
-                // Wait before retry
-                await new Promise((resolve) => setTimeout(resolve, 1000 * attempt));
-            }
-        }
-        return false;
-    }
-    /**
-     * Disconnect from a device
-     */
-    async disconnect(deviceId) {
-        const connection = this.connections.get(deviceId);
-        if (connection) {
-            connection.ws.close();
-            this.connections.delete(deviceId);
-            this.emit("deviceDisconnected", { deviceId });
-        }
-    }
-    /**
-     * Broadcast message to all connected devices
-     */
-    async broadcast(message, targetDevices) {
-        const devices = targetDevices || Array.from(this.connections.keys());
-        for (const deviceId of devices) {
-            const connection = this.connections.get(deviceId);
-            if (connection && connection.isAlive) {
-                this.sendToConnection(connection, message);
-            }
-        }
-    }
-    /**
-     * Send message to specific device
-     */
-    sendToDevice(deviceId, message) {
-        const connection = this.connections.get(deviceId);
-        if (connection && connection.isAlive) {
-            this.sendToConnection(connection, message);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Get all connections
-     */
-    getConnections() {
-        return new Map(this.connections);
-    }
-    /**
-     * Get connection count
-     */
-    getConnectionCount() {
-        return this.connections.size;
-    }
-    /**
-     * Setup connection event handlers
-     */
-    setupConnectionHandlers(connection) {
-        connection.ws.onmessage = (event) => {
-            try {
-                const message = JSON.parse(event.data);
-                this.handleMessage(connection, message);
-            }
-            catch (error) {
-                console.error("Failed to parse message:", error);
-            }
-        };
-        connection.ws.onclose = () => {
-            connection.isAlive = false;
-            this.connections.delete(connection.deviceId);
-            this.emit("deviceDisconnected", { deviceId: connection.deviceId });
-        };
-        connection.ws.onerror = (error) => {
-            console.error(`WebSocket error for ${connection.deviceId}:`, error);
-            this.emit("error", error);
-        };
-    }
-    /**
-     * Handle incoming message
-     */
-    handleMessage(connection, message) {
-        switch (message.type) {
-            case "handshake":
-                // Handle handshake response
-                connection.consciousnessLevel = message.consciousnessLevel;
-                this.emit("handshake", {
-                    deviceId: connection.deviceId,
-                    consciousnessLevel: message.consciousnessLevel,
-                });
-                break;
-            case "ping":
-                // Respond to ping
-                this.sendToConnection(connection, { type: "pong", timestamp: Date.now() });
-                break;
-            case "pong":
-                // Update last ping time
-                connection.lastPing = Date.now();
-                break;
-            default:
-                // Emit message for other handlers
-                this.emit("message", {
-                    deviceId: connection.deviceId,
-                    message,
-                });
-        }
-    }
-    /**
-     * Send message to connection
-     */
-    sendToConnection(connection, message) {
-        try {
-            connection.ws.send(message);
-        }
-        catch (error) {
-            console.error(`Failed to send message to ${connection.deviceId}:`, error);
-        }
-    }
-    /**
-     * Ping all connections
-     */
-    pingConnections() {
-        const now = Date.now();
-        for (const [, connection] of this.connections) {
-            if (now - connection.lastPing > 60000) { // 60 seconds
-                connection.isAlive = false;
-                connection.ws.close();
-                this.connections.delete(connection.deviceId);
-                this.emit("deviceDisconnected", { deviceId: connection.deviceId });
-            }
-            else {
-                this.sendToConnection(connection, { type: "ping", timestamp: now });
-            }
-        }
-    }
-    /**
-     * Start device discovery (simplified for browser)
-     */
-    startDiscovery() {
-        // In browser environment, discovery would typically use
-        // WebRTC, local storage, or external signaling servers
-        console.log("🔍 Device discovery started (browser mode)");
-    }
-    /**
-     * Check if node is running
-     */
-    isNodeRunning() {
-        return this.isRunning;
-    }
-    /**
-     * Get network insights
-     */
-    getInsights() {
-        return {
-            connectionCount: this.connections.size,
-            isRunning: this.isRunning,
-            deviceId: this.config.deviceId,
-            maxConnections: this.config.maxConnections,
-            connections: Array.from(this.connections.keys()),
-        };
-    }
-    /**
-     * Check if the node is connected to any devices
-     */
-    isConnected() {
-        return this.connections.size > 0;
-    }
-    /**
-     * Broadcast message to all connected devices
-     */
-    async broadcastMessage(message) {
-        return this.broadcast(message);
-    }
-    /**
-     * Process incoming message
-     */
-    async processMessage() {
-        // This method is called by tests but doesn't need to do anything
-        // as message processing is handled automatically by the WebSocket handlers
-    }
-    /**
-     * Get connection status
-     */
-    getConnectionStatus() {
-        return this.isConnected();
-    }
-}
-exports.BrowserNetworkNode = BrowserNetworkNode;