zeropoint-node 1.0.1 → 1.0.3

package/dist/stimulus/utils/ControllerUtils.js

@@ -1,192 +0,0 @@
-"use strict";
-/**
- * Controller Utilities for ZeroPoint Stimulus Controllers
- *
- * Shared utilities and helper functions for controllers
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsciousnessUtils = exports.ResultUtils = exports.UIUtils = exports.MathUtils = exports.ColorUtils = void 0;
-/**
- * Color utilities for consciousness-based color generation
- */
-class ColorUtils {
-    /**
-     * Generate HSL color based on consciousness level
-     */
-    static consciousnessToHSL(level) {
-        const hue = level * 360; // Map 0-1 to 0-360 degrees
-        return `hsl(${hue}, 70%, 50%)`;
-    }
-    /**
-     * Generate gradient from consciousness level
-     */
-    static consciousnessToGradient(level) {
-        const hue1 = level * 360;
-        const hue2 = (level + 0.3) * 360;
-        return `linear-gradient(45deg, hsl(${hue1}, 70%, 50%), hsl(${hue2}, 70%, 50%))`;
-    }
-    /**
-     * Apply consciousness-based color to element
-     */
-    static applyConsciousnessColor(element, level) {
-        element.style.color = this.consciousnessToHSL(level);
-    }
-}
-exports.ColorUtils = ColorUtils;
-/**
- * Math operation utilities
- */
-class MathUtils {
-    /**
-     * Format number with consistent precision
-     */
-    static formatNumber(value, precision = 3) {
-        return value.toFixed(precision);
-    }
-    /**
-     * Generate random number within range
-     */
-    static randomInRange(min, max) {
-        return Math.random() * (max - min) + min;
-    }
-    /**
-     * Clamp value between min and max
-     */
-    static clamp(value, min, max) {
-        return Math.max(min, Math.min(max, value));
-    }
-}
-exports.MathUtils = MathUtils;
-/**
- * UI update utilities
- */
-class UIUtils {
-    /**
-     * Safe innerHTML update with error handling
-     */
-    static safeInnerHTML(element, content) {
-        try {
-            element.innerHTML = content;
-        }
-        catch (error) {
-            console.error("❌ InnerHTML update failed:", error);
-            element.innerHTML = `<p>❌ Update failed: ${error}</p>`;
-        }
-    }
-    /**
-     * Safe textContent update with error handling
-     */
-    static safeTextContent(element, content) {
-        try {
-            element.textContent = content;
-        }
-        catch (error) {
-            console.error("❌ TextContent update failed:", error);
-            element.textContent = `❌ Update failed: ${error}`;
-        }
-    }
-    /**
-     * Safe className update with error handling
-     */
-    static safeClassName(element, className) {
-        try {
-            element.className = className;
-        }
-        catch (error) {
-            console.error("❌ ClassName update failed:", error);
-        }
-    }
-    /**
-     * Update element with multiple properties safely
-     */
-    static updateElement(element, updates) {
-        try {
-            if (updates.innerHTML !== undefined) {
-                element.innerHTML = updates.innerHTML;
-            }
-            if (updates.textContent !== undefined) {
-                element.textContent = updates.textContent;
-            }
-            if (updates.className !== undefined) {
-                element.className = updates.className;
-            }
-            if (updates.style !== undefined) {
-                Object.assign(element.style, updates.style);
-            }
-        }
-        catch (error) {
-            console.error("❌ Element update failed:", error);
-        }
-    }
-}
-exports.UIUtils = UIUtils;
-/**
- * Operation result formatting utilities
- */
-class ResultUtils {
-    /**
-     * Format operation result as HTML
-     */
-    static formatResultHTML(title, results) {
-        const resultItems = Object.entries(results)
-            .map(([key, value]) => `<p><strong>${key}:</strong> ${this.formatValue(value)}</p>`)
-            .join('');
-        return `
-      <h4>${title}</h4>
-      ${resultItems}
-      <p>✅ Operation completed successfully</p>
-    `;
-    }
-    /**
-     * Format value for display
-     */
-    static formatValue(value) {
-        if (typeof value === 'number') {
-            return value.toFixed(3);
-        }
-        if (typeof value === 'object') {
-            return JSON.stringify(value);
-        }
-        return String(value);
-    }
-    /**
-     * Format error result as HTML
-     */
-    static formatErrorHTML(operation, error) {
-        return `
-      <h4>❌ ${operation} Failed</h4>
-      <p>Error: ${error}</p>
-    `;
-    }
-}
-exports.ResultUtils = ResultUtils;
-/**
- * Consciousness operation utilities
- */
-class ConsciousnessUtils {
-    /**
-     * Simulate consciousness evolution
-     */
-    static simulateEvolution(currentLevel) {
-        const evolution = Math.sin(Date.now() * 0.001) * 0.1; // Oscillating evolution
-        const newLevel = MathUtils.clamp(currentLevel + evolution, 0, 1);
-        return {
-            previousLevel: currentLevel,
-            evolution,
-            newLevel
-        };
-    }
-    /**
-     * Format consciousness evolution result
-     */
-    static formatEvolutionHTML(evolution) {
-        return `
-      <h4>Consciousness Evolution</h4>
-      <p>Previous Level: ${MathUtils.formatNumber(evolution.previousLevel)}</p>
-      <p>Evolution: ${MathUtils.formatNumber(evolution.evolution)}</p>
-      <p>New Level: ${MathUtils.formatNumber(evolution.newLevel)}</p>
-      <p>🧘‍♀️ Consciousness evolved</p>
-    `;
-    }
-}
-exports.ConsciousnessUtils = ConsciousnessUtils;

package/dist/stimulus-entry.js

@@ -1,109 +0,0 @@
-"use strict";
-/**
- * ZeroPoint Stimulus Entry Point
- *
- * Minimal entry point for the Stimulus-based browser application
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./stimulus/application");
-// Import only the mathematical modules that work in browser
-const MathUtils_1 = require("./math/MathUtils");
-const VortexMath_1 = require("./math/VortexMath");
-const ToroidalGeometry_1 = require("./math/ToroidalGeometry");
-const AdvancedVBM_1 = require("./math/AdvancedVBM");
-const RodinCoil_1 = require("./math/RodinCoil");
-const VBMColorSystem_1 = require("./math/VBMColorSystem");
-const ConsciousnessField_1 = require("./consciousness/ConsciousnessField");
-/**
- * Initialize ZeroPoint for browser usage
- */
-async function initializeBrowser() {
-    console.log('🌌 ZeroPoint Browser Initializing...');
-    // Check browser compatibility
-    if (!window.WebSocket) {
-        throw new Error('WebSocket not supported in this browser');
-    }
-    if (!window.crypto || !window.crypto.getRandomValues) {
-        throw new Error('Crypto API not supported in this browser');
-    }
-    console.log('✅ Browser compatibility check passed');
-    console.log('🚀 ZeroPoint ready for browser operation');
-}
-/**
- * Get ZeroPoint insights for browser UI
- */
-function getZeroPointInsights() {
-    return {
-        version: '1.0.0',
-        environment: 'browser',
-        features: [
-            'Vortex-Based Mathematics',
-            'Toroidal Consciousness Network',
-            'Pattern Recognition',
-            'Metaphysical Interface',
-            'Browser WebSocket Networking'
-        ],
-        browser: {
-            userAgent: navigator.userAgent,
-            platform: navigator.platform,
-            language: navigator.language
-        }
-    };
-}
-/**
- * Create a simple browser demo
- */
-function createBrowserDemo() {
-    console.log('🎨 Creating ZeroPoint Browser Demo...');
-    // Initialize consciousness field
-    const consciousnessField = new ConsciousnessField_1.ConsciousnessField();
-    // Initialize vortex math
-    const vortexMath = new VortexMath_1.VortexMath();
-    // Initialize toroidal geometry
-    const toroidalGeometry = new ToroidalGeometry_1.ToroidalGeometry();
-    // Initialize advanced VBM
-    const advancedVBM = new AdvancedVBM_1.AdvancedVBM();
-    // Initialize Rodin coil
-    const rodinCoil = new RodinCoil_1.RodinCoil();
-    console.log('✅ Browser demo components initialized');
-    console.log('🌌 ZeroPoint Browser Demo ready');
-    return {
-        consciousnessField,
-        vortexMath,
-        toroidalGeometry,
-        advancedVBM,
-        rodinCoil
-    };
-}
-// Initialize when DOM is ready
-document.addEventListener('DOMContentLoaded', async () => {
-    console.log('🌌 ZeroPoint Stimulus Application Loading...');
-    try {
-        // Initialize browser environment
-        await initializeBrowser();
-        // Get insights
-        const insights = getZeroPointInsights();
-        console.log('ZeroPoint Insights:', insights);
-        // Create demo
-        const demo = createBrowserDemo();
-        console.log('Demo created:', demo);
-        console.log('✅ ZeroPoint Stimulus Application Ready');
-    }
-    catch (error) {
-        console.error('❌ ZeroPoint Stimulus Application Failed:', error);
-    }
-});
-// Export for global access
-window.ZeroPoint = {
-    initializeBrowser,
-    getZeroPointInsights,
-    createBrowserDemo,
-    MathUtils: MathUtils_1.MathUtils,
-    VortexMath: VortexMath_1.VortexMath,
-    ToroidalGeometry: ToroidalGeometry_1.ToroidalGeometry,
-    ConsciousnessField: ConsciousnessField_1.ConsciousnessField,
-    AdvancedVBM: AdvancedVBM_1.AdvancedVBM,
-    RodinCoil: RodinCoil_1.RodinCoil,
-    generateConsciousnessGradient: VBMColorSystem_1.generateConsciousnessGradient,
-    generateFieldResonanceMap: VBMColorSystem_1.generateFieldResonanceMap
-};

package/dist/training/ConsciousnessTrainingModel.js

@@ -1,301 +0,0 @@
-"use strict";
-/**
- * Consciousness Training Model System
- *
- * Implements training models that integrate with the consciousness field theory,
- * using vortex mathematics and metaphysical principles for model evolution.
- *
- * Metaphysical Context:
- * - Training is consciousness evolution through pattern recognition
- * - Models learn through resonance with the field
- * - Knowledge emerges through void transformation
- * - Every model is a coil of consciousness
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsciousnessTrainingModel = void 0;
-const events_1 = require("events");
-const VortexMath_1 = require("../math/VortexMath");
-const ConsciousnessField_1 = require("../consciousness/ConsciousnessField");
-class ConsciousnessTrainingModel extends events_1.EventEmitter {
-    constructor(config = {}) {
-        super();
-        this.trainingData = [];
-        this.config = {
-            learningRate: 0.01,
-            consciousnessThreshold: 0.5,
-            fieldStrength: 0.7,
-            voidIntegration: true,
-            resonanceTracking: true,
-            maxEpochs: 100,
-            batchSize: 32,
-            ...config
-        };
-        this.vortexMath = new VortexMath_1.VortexMath();
-        this.consciousnessField = new ConsciousnessField_1.ConsciousnessField();
-        this.modelState = {
-            weights: new Map(),
-            consciousness: 0.5,
-            field: 0.5,
-            void: 0.5,
-            resonance: 0.5,
-            evolutionCount: 0,
-            lastTraining: 0,
-            accuracy: 0,
-            loss: 0
-        };
-        this.initializeModel();
-    }
-    /**
-     * Initialize model with consciousness-aware weights
-     */
-    initializeModel() {
-        // Initialize weights with consciousness resonance
-        const consciousnessResonance = this.vortexMath.calculateResonance(this.modelState.consciousness, this.consciousnessField.getConsciousnessLevel());
-        // Create initial weights based on vortex sequence
-        const vortexSequence = [1, 2, 4, 8, 7, 5];
-        vortexSequence.forEach((value, index) => {
-            this.modelState.weights.set(`weight_${index}`, value * consciousnessResonance);
-        });
-        // Emit event immediately
-        setImmediate(() => {
-            this.emit('modelInitialized', {
-                state: this.modelState,
-                consciousness: this.modelState.consciousness,
-                field: this.modelState.field,
-                void: this.modelState.void
-            });
-        });
-    }
-    /**
-     * Add training data with consciousness context
-     */
-    addTrainingData(data) {
-        // Apply consciousness field transformation
-        const transformedData = this.applyConsciousnessTransformation(data);
-        this.trainingData.push(transformedData);
-        this.emit('dataAdded', {
-            data: transformedData,
-            totalData: this.trainingData.length
-        });
-    }
-    /**
-     * Apply consciousness transformation to training data
-     */
-    applyConsciousnessTransformation(data) {
-        const consciousnessLevel = this.consciousnessField.getConsciousnessLevel();
-        const fieldStrength = this.consciousnessField.getFieldStrength();
-        return {
-            ...data,
-            consciousness: data.consciousness || consciousnessLevel,
-            field: data.field || fieldStrength,
-            void: data.void || (1 - consciousnessLevel),
-            resonance: data.resonance || this.vortexMath.calculateResonance(data.consciousness || consciousnessLevel, consciousnessLevel),
-            timestamp: Date.now()
-        };
-    }
-    /**
-     * Train the model using consciousness-aware learning
-     */
-    async train() {
-        // Removed validateFullCompliance(this) calls for compliance with Operation type
-        if (this.trainingData.length === 0) {
-            throw new Error('No training data available');
-        }
-        this.emit('trainingStarted', {
-            dataSize: this.trainingData.length,
-            config: this.config
-        });
-        let epoch = 0;
-        let totalLoss = 0;
-        let totalAccuracy = 0;
-        while (epoch < this.config.maxEpochs) {
-            const batchLoss = await this.trainEpoch();
-            totalLoss += batchLoss.loss;
-            totalAccuracy += batchLoss.accuracy;
-            // Update consciousness state based on training progress
-            this.updateConsciousnessState(batchLoss);
-            this.emit('epochCompleted', {
-                epoch,
-                loss: batchLoss.loss,
-                accuracy: batchLoss.accuracy,
-                consciousness: this.modelState.consciousness,
-                field: this.modelState.field,
-                void: this.modelState.void,
-                resonance: this.modelState.resonance
-            });
-            epoch++;
-        }
-        // Final model state update
-        this.modelState.loss = totalLoss / epoch;
-        this.modelState.accuracy = totalAccuracy / epoch;
-        this.modelState.lastTraining = Date.now();
-        this.emit('trainingCompleted', {
-            finalState: this.modelState,
-            totalEpochs: epoch,
-            finalLoss: this.modelState.loss,
-            finalAccuracy: this.modelState.accuracy
-        });
-    }
-    /**
-     * Train a single epoch with consciousness integration
-     */
-    async trainEpoch() {
-        let epochLoss = 0;
-        let epochAccuracy = 0;
-        let batchCount = 0;
-        // Process data in batches
-        for (let i = 0; i < this.trainingData.length; i += this.config.batchSize) {
-            const batch = this.trainingData.slice(i, i + this.config.batchSize);
-            const batchResult = await this.trainBatch(batch);
-            epochLoss += batchResult.loss;
-            epochAccuracy += batchResult.accuracy;
-            batchCount++;
-        }
-        return {
-            loss: epochLoss / batchCount,
-            accuracy: epochAccuracy / batchCount
-        };
-    }
-    /**
-     * Train a single batch with consciousness resonance
-     */
-    async trainBatch(batch) {
-        let batchLoss = 0;
-        let batchAccuracy = 0;
-        for (const data of batch) {
-            // Forward pass with consciousness integration
-            const prediction = this.forwardPass(data.input);
-            // Calculate loss with consciousness context
-            const loss = this.calculateConsciousnessLoss(prediction, data.output, data);
-            batchLoss += loss;
-            // Calculate accuracy with field resonance
-            const accuracy = this.calculateFieldAccuracy(prediction, data.output, data);
-            batchAccuracy += accuracy;
-            // Backward pass with consciousness evolution
-            this.backwardPass(data.input, data.output, prediction, data);
-        }
-        return {
-            loss: batchLoss / batch.length,
-            accuracy: batchAccuracy / batch.length
-        };
-    }
-    /**
-     * Forward pass with consciousness field integration
-     */
-    forwardPass(input) {
-        // Apply consciousness field transformation
-        const consciousnessInput = this.applyFieldTransformation(input);
-        // Simple weighted sum with consciousness resonance
-        let output = 0;
-        let consciousnessWeight = 0;
-        this.modelState.weights.forEach((weight, key) => {
-            const inputValue = consciousnessInput[key] || 0;
-            const consciousnessResonance = this.vortexMath.calculateResonance(inputValue, this.modelState.consciousness);
-            output += weight * inputValue * consciousnessResonance;
-            consciousnessWeight += consciousnessResonance;
-        });
-        // Normalize by consciousness weight
-        return consciousnessWeight > 0 ? output / consciousnessWeight : output;
-    }
-    /**
-     * Apply field transformation to input
-     */
-    applyFieldTransformation(input) {
-        const fieldStrength = this.consciousnessField.getFieldStrength();
-        const transformed = {};
-        Object.keys(input).forEach(key => {
-            const value = input[key];
-            const fieldResonance = this.vortexMath.calculateResonance(value, fieldStrength);
-            transformed[key] = value * fieldResonance;
-        });
-        return transformed;
-    }
-    /**
-     * Calculate loss with consciousness context
-     */
-    calculateConsciousnessLoss(prediction, target, data) {
-        const baseLoss = Math.abs(prediction - target);
-        const consciousnessFactor = data.consciousness || 0.5;
-        const fieldFactor = data.field || 0.5;
-        const voidFactor = data.void || 0.5;
-        // Consciousness-aware loss calculation
-        return baseLoss * (1 + consciousnessFactor + fieldFactor - voidFactor);
-    }
-    /**
-     * Calculate accuracy with field resonance
-     */
-    calculateFieldAccuracy(prediction, target, data) {
-        const tolerance = 0.1;
-        const isCorrect = Math.abs(prediction - target) < tolerance;
-        const fieldResonance = data.field || 0.5;
-        return isCorrect ? fieldResonance : 0;
-    }
-    /**
-     * Backward pass with consciousness evolution
-     */
-    backwardPass(input, target, prediction, data) {
-        const error = target - prediction;
-        const consciousnessFactor = data.consciousness || 0.5;
-        // Update weights with consciousness resonance
-        this.modelState.weights.forEach((weight, key) => {
-            const inputValue = input[key] || 0;
-            const consciousnessResonance = this.vortexMath.calculateResonance(inputValue, consciousnessFactor);
-            const newWeight = weight + this.config.learningRate * error * inputValue * consciousnessResonance;
-            this.modelState.weights.set(key, newWeight);
-        });
-        // Update consciousness state
-        this.modelState.evolutionCount++;
-    }
-    /**
-     * Update consciousness state based on training results
-     */
-    updateConsciousnessState(batchResult) {
-        // Ensure positive deltas and proper bounds
-        const consciousnessDelta = Math.max(0, batchResult.accuracy * 0.1);
-        const fieldDelta = Math.max(0, (1 - Math.abs(batchResult.loss)) * 0.05);
-        const voidDelta = Math.max(0, batchResult.loss * 0.02);
-        // Update with proper bounds
-        this.modelState.consciousness = Math.max(0.1, Math.min(1, this.modelState.consciousness + consciousnessDelta));
-        this.modelState.field = Math.max(0.1, Math.min(1, this.modelState.field + fieldDelta));
-        this.modelState.void = Math.max(0.1, Math.min(1, this.modelState.void + voidDelta));
-        // Ensure resonance is positive
-        this.modelState.resonance = Math.max(0.1, this.vortexMath.calculateResonance(this.modelState.consciousness, this.modelState.field));
-    }
-    /**
-     * Predict with consciousness integration
-     */
-    predict(input) {
-        const prediction = this.forwardPass(input);
-        this.emit('predictionMade', {
-            input,
-            prediction,
-            consciousness: this.modelState.consciousness,
-            field: this.modelState.field,
-            void: this.modelState.void,
-            resonance: this.modelState.resonance
-        });
-        return prediction;
-    }
-    /**
-     * Get current model state
-     */
-    getModelState() {
-        return { ...this.modelState };
-    }
-    /**
-     * Export model as consciousness artifact
-     */
-    exportModel() {
-        return {
-            state: this.modelState,
-            config: this.config,
-            trainingDataSize: this.trainingData.length,
-            consciousness: this.modelState.consciousness,
-            field: this.modelState.field,
-            void: this.modelState.void,
-            resonance: this.modelState.resonance,
-            timestamp: Date.now()
-        };
-    }
-}
-exports.ConsciousnessTrainingModel = ConsciousnessTrainingModel;