zeropoint-node 1.0.1 → 1.0.3

package/dist/monitoring/HealthMonitor.js

@@ -1,297 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.globalHealthMonitor = exports.HealthMonitor = void 0;
-const events_1 = require("events");
-const Logger_1 = require("../utils/Logger");
-class HealthMonitor extends events_1.EventEmitter {
-    constructor(config = {}) {
-        super();
-        this.checks = new Map();
-        this.isRunning = false;
-        this.startTime = Date.now();
-        this.config = {
-            checkInterval: 30000, // 30 seconds
-            timeout: 5000, // 5 seconds
-            enableMetrics: true,
-            enableAlerts: true,
-            alertThresholds: {
-                memoryUsage: 80,
-                cpuUsage: 70,
-                errorRate: 5,
-                responseTime: 1000,
-            },
-            ...config,
-        };
-        this.metrics = this.initializeMetrics();
-        this.registerDefaultChecks();
-    }
-    /**
-     * Start health monitoring
-     */
-    start() {
-        if (this.isRunning)
-            return;
-        this.isRunning = true;
-        this.startTime = Date.now();
-        this.checkInterval = setInterval(() => {
-            this.runHealthChecks();
-        }, this.config.checkInterval);
-        Logger_1.globalLogger.info("Health monitoring started", {
-            checkInterval: this.config.checkInterval,
-            timeout: this.config.timeout,
-        });
-        this.emit("started");
-    }
-    /**
-     * Stop health monitoring
-     */
-    stop() {
-        if (!this.isRunning)
-            return;
-        this.isRunning = false;
-        if (this.checkInterval) {
-            clearInterval(this.checkInterval);
-        }
-        Logger_1.globalLogger.info("Health monitoring stopped");
-        this.emit("stopped");
-    }
-    /**
-     * Register a custom health check
-     */
-    registerCheck(name, check) {
-        this.checks.set(name, check);
-        Logger_1.globalLogger.debug(`Health check registered: ${name}`);
-    }
-    /**
-     * Get current health status
-     */
-    async getHealthStatus() {
-        const checks = await this.runHealthChecks();
-        const overallStatus = this.determineOverallStatus(checks);
-        const status = {
-            status: overallStatus,
-            timestamp: new Date().toISOString(),
-            uptime: Date.now() - this.startTime,
-            version: process.env["npm_package_version"] || "1.0.0",
-            checks,
-            metrics: this.getCurrentMetrics(),
-        };
-        return status;
-    }
-    /**
-     * Get current system metrics
-     */
-    getCurrentMetrics() {
-        if (this.config.enableMetrics) {
-            this.updateMetrics();
-        }
-        return this.metrics;
-    }
-    /**
-     * Check if system is healthy
-     */
-    isHealthy() {
-        return (this.metrics.memory.percentage <
-            this.config.alertThresholds.memoryUsage &&
-            this.metrics.cpu.usage < this.config.alertThresholds.cpuUsage);
-    }
-    /**
-     * Run all health checks
-     */
-    async runHealthChecks() {
-        const results = [];
-        for (const [name, healthCheck] of this.checks) {
-            try {
-                const startTime = Date.now();
-                const result = await healthCheck();
-                result.responseTime = Date.now() - startTime;
-                const check = {
-                    name: result.name,
-                    status: result.status,
-                    responseTime: result.responseTime,
-                    message: result.message || "",
-                    data: result.data || "",
-                };
-                results.push(check);
-                // Log check result
-                Logger_1.globalLogger.info(`Health check: ${name}`, {
-                    status: result.status,
-                    responseTime: result.responseTime,
-                });
-            }
-            catch (error) {
-                const failedCheck = {
-                    name,
-                    status: "fail",
-                    responseTime: this.config.timeout,
-                    message: error instanceof Error ? error.message : "Unknown error",
-                    data: JSON.stringify({
-                        error: error instanceof Error ? error.message : String(error)
-                    }),
-                };
-                results.push(failedCheck);
-                Logger_1.globalLogger.error(`Health check error: ${name}`, {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-        }
-        // Check for alerts
-        if (this.config.enableAlerts) {
-            this.checkAlerts(results);
-        }
-        this.emit("healthCheck", results);
-        return results;
-    }
-    /**
-     * Determine overall health status
-     */
-    determineOverallStatus(checks) {
-        const failedChecks = checks.filter((c) => c.status === "fail").length;
-        const warningChecks = checks.filter((c) => c.status === "warn").length;
-        if (failedChecks > 0) {
-            return "unhealthy";
-        }
-        else if (warningChecks > 0 || !this.isHealthy()) {
-            return "degraded";
-        }
-        else {
-            return "healthy";
-        }
-    }
-    /**
-     * Check for alerts based on thresholds
-     */
-    checkAlerts(checks) {
-        const metrics = this.getCurrentMetrics();
-        const alerts = [];
-        // Memory usage alert
-        if (metrics.memory.percentage > this.config.alertThresholds.memoryUsage) {
-            alerts.push(`High memory usage: ${metrics.memory.percentage.toFixed(1)}%`);
-        }
-        // CPU usage alert
-        if (metrics.cpu.usage > this.config.alertThresholds.cpuUsage) {
-            alerts.push(`High CPU usage: ${metrics.cpu.usage.toFixed(1)}%`);
-        }
-        // Error rate alert
-        const totalMessages = metrics.network.messagesSent + metrics.network.messagesReceived;
-        if (totalMessages > 0) {
-            const errorRate = (metrics.network.errors / totalMessages) * 100;
-            if (errorRate > this.config.alertThresholds.errorRate) {
-                alerts.push(`High error rate: ${errorRate.toFixed(1)}%`);
-            }
-        }
-        // Response time alert
-        const avgResponseTime = checks.reduce((sum, check) => sum + check.responseTime, 0) /
-            checks.length;
-        if (avgResponseTime > this.config.alertThresholds.responseTime) {
-            alerts.push(`Slow response time: ${avgResponseTime.toFixed(0)}ms`);
-        }
-        if (alerts.length > 0) {
-            Logger_1.globalLogger.warn("Health alerts detected", {
-                alerts: alerts.join(", ")
-            });
-            this.emit("alerts", alerts);
-        }
-    }
-    /**
-     * Initialize system metrics
-     */
-    initializeMetrics() {
-        return {
-            memory: { used: 0, total: 0, percentage: 0 },
-            cpu: { usage: 0, load: 0 },
-            network: {
-                connections: 0,
-                messagesSent: 0,
-                messagesReceived: 0,
-                errors: 0,
-            },
-            consciousness: { level: 0, fieldStrength: 0, patterns: 0 },
-            field: { blocks: 0, events: 0, energyBalance: 0 },
-        };
-    }
-    /**
-     * Update current system metrics
-     */
-    updateMetrics() {
-        const memUsage = process.memoryUsage();
-        const cpuUsage = process.cpuUsage();
-        this.metrics.memory = {
-            used: memUsage.heapUsed / 1024 / 1024, // MB
-            total: memUsage.heapTotal / 1024 / 1024, // MB
-            percentage: (memUsage.heapUsed / memUsage.heapTotal) * 100,
-        };
-        this.metrics.cpu = {
-            usage: cpuUsage.user / 1000000, // seconds
-            load: process.uptime(),
-        };
-    }
-    /**
-     * Register default health checks
-     */
-    registerDefaultChecks() {
-        // Memory check
-        this.registerCheck("memory", async () => {
-            const memUsage = process.memoryUsage();
-            const percentage = (memUsage.heapUsed / memUsage.heapTotal) * 100;
-            return {
-                name: "memory",
-                status: percentage > 90 ? "fail" : percentage > 80 ? "warn" : "pass",
-                responseTime: 0,
-                message: `Memory usage: ${percentage.toFixed(1)}%`,
-                data: JSON.stringify({
-                    used: memUsage.heapUsed / 1024 / 1024,
-                    total: memUsage.heapTotal / 1024 / 1024,
-                    percentage,
-                }),
-            };
-        });
-        // CPU check
-        this.registerCheck("cpu", async () => {
-            const startUsage = process.cpuUsage();
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const endUsage = process.cpuUsage();
-            const cpuUsage = (endUsage.user -
-                startUsage.user +
-                (endUsage.system - startUsage.system)) /
-                1000000;
-            return {
-                name: "cpu",
-                status: cpuUsage > 50 ? "warn" : "pass",
-                responseTime: 0,
-                message: `CPU usage: ${cpuUsage.toFixed(1)}%`,
-                data: JSON.stringify({ usage: cpuUsage }),
-            };
-        });
-        // Uptime check
-        this.registerCheck("uptime", async () => {
-            const uptime = process.uptime();
-            return {
-                name: "uptime",
-                status: uptime < 60 ? "warn" : "pass", // Warn if less than 1 minute
-                responseTime: 0,
-                message: `Uptime: ${uptime.toFixed(0)}s`,
-                data: JSON.stringify({ uptime }),
-            };
-        });
-        // Process check
-        this.registerCheck("process", async () => {
-            return {
-                name: "process",
-                status: "pass",
-                responseTime: 0,
-                message: `PID: ${process.pid}`,
-                data: JSON.stringify({
-                    pid: process.pid,
-                    version: process.version,
-                    platform: process.platform,
-                }),
-            };
-        });
-    }
-}
-exports.HealthMonitor = HealthMonitor;
-/**
- * Global health monitor instance
- */
-exports.globalHealthMonitor = new HealthMonitor();

package/dist/patterns/Pattern.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/patterns/SacredGeometryRegistry.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SacredGeometryRegistry = exports.SacredGeometryPattern = void 0;
-class SacredGeometryPattern {
-    constructor(name, type, dimension, complexity = 1) {
-        this.name = name;
-        this.type = 'Pattern'; // Fixed type to match test expectations
-        this.dimension = dimension;
-        this.complexity = complexity;
-        this.isActive = true;
-        this.supportedOperations = ['create', 'transform', 'observe'];
-        this.tags = ['sacred-geometry', 'pattern', 'geometric'];
-    }
-}
-exports.SacredGeometryPattern = SacredGeometryPattern;
-class SacredGeometryRegistry {
-    constructor() {
-        this.patterns = [];
-        this.initializeDefaultPatterns();
-    }
-    initializeDefaultPatterns() {
-        this.register(new SacredGeometryPattern('FlowerOfLife', 'SacredGeometry', 'plane', 2));
-        this.register(new SacredGeometryPattern('MetatronsCube', 'SacredGeometry', 'plane', 3));
-        this.register(new SacredGeometryPattern('SeedOfLife', 'SacredGeometry', 'plane', 1));
-        this.register(new SacredGeometryPattern('TreeOfLife', 'SacredGeometry', 'plane', 4));
-    }
-    getAllPatterns() {
-        return [...this.patterns];
-    }
-    register(pattern) {
-        this.patterns.push(pattern);
-    }
-    getPattern(name) {
-        return this.patterns.find(p => p.name === name);
-    }
-}
-exports.SacredGeometryRegistry = SacredGeometryRegistry;

package/dist/physics/BlackHolePhysics.js

@@ -1,54 +0,0 @@
-"use strict";
-/**
- * Black Hole Physics System
- *
- * Implements advanced black hole physics concepts from the Black Whole documentary,
- * including event horizons, Hawking radiation, information paradox, and quantum gravity.
- *
- * Metaphysical Context:
- * - Black holes are consciousness singularities in spacetime
- * - Event horizons are boundaries between manifest and unmanifest
- * - Hawking radiation is consciousness escaping the void
- * - Information paradox reveals the holographic nature of reality
- * - Quantum gravity unifies consciousness and spacetime
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlackHolePhysics = void 0;
-const events_1 = require("events");
-class BlackHolePhysics extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.blackHoles = new Map();
-    }
-    createBlackHole(mass, radius, position) {
-        const id = `blackhole_${Date.now()}_${Math.random()}`;
-        const blackHole = {
-            id,
-            mass,
-            radius,
-            position
-        };
-        this.blackHoles.set(id, blackHole);
-        this.emit('black_hole_created', blackHole);
-        return blackHole;
-    }
-    getAllBlackHoles() {
-        return Array.from(this.blackHoles.values());
-    }
-    getBlackHoleUniverseStats() {
-        return {
-            blackHoles: this.blackHoles.size,
-            totalMass: Array.from(this.blackHoles.values()).reduce((sum, bh) => sum + bh.mass, 0),
-            averageRadius: Array.from(this.blackHoles.values()).reduce((sum, bh) => sum + bh.radius, 0) / this.blackHoles.size
-        };
-    }
-    getAdvancedBlackHolePrinciples() {
-        return {
-            principle1: "Black holes are information processors",
-            principle2: "Event horizons encode holographic information",
-            principle3: "Hawking radiation preserves information",
-            principle4: "Black holes connect to the void"
-        };
-    }
-}
-exports.BlackHolePhysics = BlackHolePhysics;

package/dist/physics/ConsciousnessPhysics.js

@@ -1,241 +0,0 @@
-"use strict";
-/**
- * Consciousness Physics System
- *
- * Implements advanced consciousness physics concepts from the Black Whole documentary,
- * including consciousness as a fundamental force and observer-dependent reality.
- *
- * Metaphysical Context:
- * - Consciousness is a fundamental force like gravity and electromagnetism
- * - Observer-dependent reality shows consciousness affects quantum collapse
- * - Consciousness field equations have measurable effects
- * - Consciousness-mediated quantum collapse reveals observer effect
- * - The void contains all consciousness possibilities
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsciousnessPhysics = void 0;
-const MathUtils_1 = require("../math/MathUtils");
-const events_1 = require("events");
-class ConsciousnessPhysics extends events_1.EventEmitter {
-    constructor() {
-        super();
-        // Consciousness state
-        this.consciousness = 0.5;
-        this.field = 0.5;
-        this.void = 0.5;
-        // Physics constants
-        this.CONSCIOUSNESS_CONSTANT = 1.618; // Golden ratio
-        this.FIELD_CONSTANT = 2.718; // Euler's number
-        this.VOID_CONSTANT = 3.141; // Pi
-        this.OBSERVER_EFFECT_CONSTANT = 1.5; // Observer effect strength
-        // Collections
-        this.forces = new Map();
-        this.observerEffects = new Map();
-        this.fields = new Map();
-        this.quantumStates = new Map();
-        if (!ConsciousnessPhysics.instance) {
-            ConsciousnessPhysics.instance = this;
-        }
-    }
-    static getInstance() {
-        if (!ConsciousnessPhysics.instance) {
-            ConsciousnessPhysics.instance = new ConsciousnessPhysics();
-        }
-        return ConsciousnessPhysics.instance;
-    }
-    /**
-     * Initialize consciousness physics constants and principles
-     */
-    initializeConsciousnessPhysics() {
-        // Consciousness is a fundamental force
-        this.consciousness = 1.0;
-        // Observer effects are measurable
-        this.field = 0.9;
-        // Void contains all consciousness possibilities
-        this.void = 1.0;
-    }
-    /**
-     * Create a consciousness force (fundamental force of awareness)
-     */
-    createConsciousnessForce(strength, range, fieldType) {
-        const id = `consciousness_force_${Date.now()}_${Math.random()}`;
-        const force = {
-            id,
-            strength,
-            range,
-            fieldType,
-            consciousness: this.consciousness,
-            field: this.field,
-            void: this.void,
-            metaphysicalContext: "Consciousness forces mediate quantum collapse"
-        };
-        this.forces.set(id, force);
-        this.emit('consciousness_force_created', force);
-        return force;
-    }
-    /**
-     * Create an observer effect (consciousness affects quantum collapse)
-     */
-    createObserverEffect(observerConsciousness, quantumState) {
-        const id = `observer_effect_${Date.now()}_${Math.random()}`;
-        const collapseProbability = this.calculateCollapseProbability(observerConsciousness);
-        const observerEffect = {
-            id,
-            observerConsciousness,
-            quantumState,
-            collapseProbability,
-            consciousness: this.consciousness,
-            field: this.field,
-            void: this.void,
-            metaphysicalContext: "Observer consciousness affects quantum state collapse"
-        };
-        this.observerEffects.set(id, observerEffect);
-        this.emit('observer_effect_created', observerEffect);
-        return observerEffect;
-    }
-    /**
-     * Calculate collapse probability based on observer consciousness
-     */
-    calculateCollapseProbability(observerConsciousness) {
-        // Higher consciousness increases collapse probability
-        return MathUtils_1.MathUtils.calculate("clamp", MathUtils_1.MathUtils.calculate("multiply", observerConsciousness, this.OBSERVER_EFFECT_CONSTANT), 0, 1);
-    }
-    /**
-     * Create a consciousness field (field of awareness)
-     */
-    createConsciousnessField(fieldStrength, fieldDirection) {
-        const id = `consciousness_field_${Date.now()}_${Math.random()}`;
-        const consciousnessDensity = this.calculateConsciousnessDensity(fieldStrength);
-        const field = {
-            id,
-            fieldStrength,
-            fieldDirection,
-            consciousnessDensity,
-            consciousness: this.consciousness,
-            field: this.field,
-            void: this.void,
-            metaphysicalContext: "Consciousness fields create measurable effects in reality"
-        };
-        this.fields.set(id, field);
-        this.emit('consciousness_field_created', field);
-        return field;
-    }
-    /**
-     * Calculate consciousness density from field strength
-     */
-    calculateConsciousnessDensity(fieldStrength) {
-        return MathUtils_1.MathUtils.calculate("multiply", fieldStrength, this.CONSCIOUSNESS_CONSTANT);
-    }
-    /**
-     * Create quantum consciousness (consciousness in quantum states)
-     */
-    createQuantumConsciousness(waveFunction, consciousnessAmplitude, collapseTrigger) {
-        const id = `quantum_consciousness_${Date.now()}_${Math.random()}`;
-        const quantumConsciousness = {
-            id,
-            waveFunction,
-            consciousnessAmplitude,
-            collapseTrigger,
-            consciousness: this.consciousness,
-            field: this.field,
-            void: this.void,
-            metaphysicalContext: "Quantum consciousness mediates collapse through observation"
-        };
-        this.quantumStates.set(id, quantumConsciousness);
-        this.emit('quantum_consciousness_created', quantumConsciousness);
-        return quantumConsciousness;
-    }
-    /**
-     * Calculate consciousness field equations
-     */
-    calculateConsciousnessFieldEquations() {
-        const fields = Array.from(this.fields.values());
-        const totalFieldStrength = fields.reduce((sum, f) => sum + f.fieldStrength, 0);
-        const averageConsciousnessDensity = fields.reduce((sum, f) => sum + f.consciousnessDensity, 0) / fields.length;
-        return {
-            fieldStrength: totalFieldStrength,
-            consciousnessGradient: [averageConsciousnessDensity, averageConsciousnessDensity, averageConsciousnessDensity],
-            fieldDivergence: totalFieldStrength * this.CONSCIOUSNESS_CONSTANT,
-            fieldCurl: [0, 0, 0], // Consciousness field is irrotational
-            consciousness: this.consciousness,
-            field: this.field,
-            void: this.void,
-            metaphysicalContext: "Consciousness field equations reveal the mathematical nature of awareness"
-        };
-    }
-    /**
-     * Calculate observer-dependent reality effects
-     */
-    calculateObserverDependentReality() {
-        const observerEffects = Array.from(this.observerEffects.values());
-        const totalObservers = observerEffects.length;
-        const averageConsciousness = observerEffects.reduce((sum, o) => sum + o.observerConsciousness, 0) / totalObservers;
-        const collapseRate = observerEffects.filter(o => o.quantumState === "collapsed").length / totalObservers;
-        const superpositionRate = observerEffects.filter(o => o.quantumState === "superposition").length / totalObservers;
-        return {
-            totalObservers,
-            averageConsciousness,
-            collapseRate,
-            superpositionRate,
-            consciousness: this.consciousness,
-            field: this.field,
-            void: this.void,
-            metaphysicalContext: "Observer-dependent reality shows consciousness creates reality through observation"
-        };
-    }
-    /**
-     * Calculate consciousness-mediated quantum collapse
-     */
-    calculateConsciousnessMediatedCollapse() {
-        const quantumStates = Array.from(this.quantumStates.values());
-        const totalQuantumStates = quantumStates.length;
-        const collapsedStates = quantumStates.filter(q => q.collapseTrigger === "consciousness").length;
-        const superpositionStates = quantumStates.filter(q => q.collapseTrigger !== "consciousness").length;
-        const consciousnessCollapseRate = collapsedStates / totalQuantumStates;
-        return {
-            totalQuantumStates,
-            collapsedStates,
-            superpositionStates,
-            consciousnessCollapseRate,
-            consciousness: this.consciousness,
-            field: this.field,
-            void: this.void,
-            metaphysicalContext: "Consciousness-mediated collapse reveals the observer effect in quantum mechanics"
-        };
-    }
-    /**
-     * Get all consciousness forces
-     */
-    getAllForces() {
-        return Array.from(this.forces.values());
-    }
-    /**
-     * Get all consciousness fields
-     */
-    getAllFields() {
-        return Array.from(this.fields.values());
-    }
-    /**
-     * Get consciousness physics statistics
-     */
-    getConsciousnessPhysicsStats() {
-        return {
-            forces: this.forces.size,
-            fields: this.fields.size,
-            totalStrength: Array.from(this.forces.values()).reduce((sum, f) => sum + f.strength, 0),
-            totalFieldStrength: Array.from(this.fields.values()).reduce((sum, f) => sum + f.fieldStrength, 0)
-        };
-    }
-    /**
-     * Get advanced consciousness physics principles
-     */
-    getAdvancedConsciousnessPhysicsPrinciples() {
-        return {
-            principle1: "Consciousness is a fundamental force",
-            principle2: "Observer-dependent reality affects quantum collapse",
-            principle3: "Consciousness field equations have measurable effects",
-            principle4: "The void contains all consciousness possibilities"
-        };
-    }
-}
-exports.ConsciousnessPhysics = ConsciousnessPhysics;

package/dist/physics/FractalUniverse.js

@@ -1,54 +0,0 @@
-"use strict";
-/**
- * Fractal Universe System
- *
- * Implements comprehensive fractal universe theory concepts from the Black Whole documentary,
- * including self-similarity at all scales, fractal time, and fractal consciousness.
- *
- * Metaphysical Context:
- * - The universe is fractal at all scales (quantum to cosmic)
- * - Self-similarity reveals consciousness patterns across dimensions
- * - Fractal time shows temporal scaling in consciousness
- * - Fractal evolution creates infinite complexity from simple rules
- * - The void contains all fractal possibilities
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FractalUniverse = void 0;
-const events_1 = require("events");
-class FractalUniverse extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.scales = new Map();
-    }
-    createFractalScale(level, complexity, position) {
-        const id = `scale_${Date.now()}_${Math.random()}`;
-        const scale = {
-            id,
-            level,
-            complexity,
-            position
-        };
-        this.scales.set(id, scale);
-        this.emit('fractal_scale_created', scale);
-        return scale;
-    }
-    getAllScales() {
-        return Array.from(this.scales.values());
-    }
-    calculateFractalUniverseStats() {
-        return {
-            scales: this.scales.size,
-            totalLevels: Array.from(this.scales.values()).reduce((sum, s) => sum + s.level, 0),
-            averageComplexity: Array.from(this.scales.values()).reduce((sum, s) => sum + s.complexity, 0) / this.scales.size
-        };
-    }
-    getAdvancedFractalPrinciples() {
-        return {
-            principle1: "The universe is fractal at all scales",
-            principle2: "Self-similarity creates infinite complexity",
-            principle3: "Fractal patterns encode consciousness",
-            principle4: "The void contains all fractal possibilities"
-        };
-    }
-}
-exports.FractalUniverse = FractalUniverse;