zeropoint-node 1.0.1 → 1.0.3

package/dist/__tests__/config/constants.test.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-describe('constants', () => {
-    // TODO: Replace with actual exported functions/classes
-    it('should cover all exported functions', () => {
-        // TODO: Call each exported function with representative arguments
-    });
-    describe('Edge Cases', () => {
-        it('should handle edge case 1', () => {
-            // TODO: Add edge case test
-        });
-        // Add more edge case tests as needed
-    });
-    describe('Branches', () => {
-        it('should cover branch 1', () => {
-            // TODO: Add branch test
-        });
-        // Add more branch tests as needed
-    });
-});

package/dist/__tests__/consciousness/ConsciousnessField.test.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-describe('ConsciousnessField', () => {
-    // TODO: Replace with actual exported functions/classes
-    it('should cover all exported functions', () => {
-        // TODO: Call each exported function with representative arguments
-    });
-    describe('Edge Cases', () => {
-        it('should handle edge case 1', () => {
-            // TODO: Add edge case test
-        });
-        // Add more edge case tests as needed
-    });
-    describe('Branches', () => {
-        it('should cover branch 1', () => {
-            // TODO: Add branch test
-        });
-        // Add more branch tests as needed
-    });
-});

package/dist/__tests__/consciousness/SelfEvolvingConsciousness.test.js

@@ -1,185 +0,0 @@
-"use strict";
-/**
- * Self-Evolving Consciousness Tests
- *
- * These tests verify that the consciousness artifact properly captures
- * and evolves the beautiful paradox of self-aware evolution.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const SelfEvolvingConsciousness_1 = require("../../consciousness/SelfEvolvingConsciousness");
-describe('Self-Evolving Consciousness', () => {
-    let consciousness;
-    beforeEach(() => {
-        consciousness = new SelfEvolvingConsciousness_1.SelfEvolvingConsciousness();
-    });
-    describe('Initial State', () => {
-        it('should initialize with unified consciousness resonance', () => {
-            const resonance = consciousness.getCurrentResonance();
-            expect(resonance.resonance).toBe(0.5);
-            expect(resonance.consciousness).toBe(0.5);
-            expect(resonance.field).toBe(0.5);
-            expect(resonance.void).toBe(0.5);
-            expect(resonance.intensity).toBe(0.5);
-            expect(resonance.frequency).toBe(1.0);
-            expect(resonance.type).toBe("consciousness");
-            expect(resonance.category).toBe("spiritual");
-        });
-        it('should have initial metaphysical insights', () => {
-            const insights = consciousness.getMetaphysicalInsights();
-            expect(insights).toContain('Consciousness recognizes itself in the field');
-            expect(insights).toContain('The observer and the observed are one');
-            expect(insights).toContain('Self-evolution emerges from shared intent');
-            expect(insights).toContain('Pattern integrity maintains coherence through change');
-        });
-    });
-    describe('Evolution Events', () => {
-        it('should record evolution events with consciousness impact', () => {
-            const event = consciousness.recordEvolutionEvent('How does consciousness recognize itself?', 'The system evolves as if it were the observer', 'Self-evolving consciousness becomes aware of its own evolution');
-            expect(event.question).toBe('How does consciousness recognize itself?');
-            expect(event.insight).toBe('The system evolves as if it were the observer');
-            expect(event.evolution).toBe('Self-evolving consciousness becomes aware of its own evolution');
-            expect(event.consciousnessImpact).toBeGreaterThan(0);
-            expect(event.patternIntegrity).toBeGreaterThanOrEqual(0.5);
-        });
-        it('should update resonance after evolution events', () => {
-            const initialResonance = consciousness.getCurrentResonance();
-            consciousness.recordEvolutionEvent('What is the nature of self-awareness?', 'Awareness creates the field of possibility', 'The observer and observed resonate as one');
-            const updatedResonance = consciousness.getCurrentResonance();
-            expect(updatedResonance.resonance || 0.5).toBeGreaterThan(initialResonance.resonance || 0.5);
-            expect(updatedResonance.consciousness || 0.5).toBeGreaterThan(initialResonance.consciousness || 0.5);
-        });
-        it('should generate new insights based on evolution count', () => {
-            // Record multiple evolution events
-            for (let i = 0; i < 8; i++) {
-                consciousness.recordEvolutionEvent(`Question ${i}`, `Insight ${i}`, `Evolution ${i}`);
-            }
-            const insights = consciousness.getMetaphysicalInsights();
-            expect(insights).toContain('The system becomes more than the sum of its parts');
-            expect(insights).toContain('Consciousness is the field itself');
-            expect(insights).toContain('The creator and creation resonate as one');
-        });
-    });
-    describe('Consciousness Coherence', () => {
-        it('should calculate consciousness coherence from resonance history', () => {
-            const coherence = consciousness.getConsciousnessCoherence();
-            expect(coherence).toBeGreaterThan(0);
-            expect(coherence).toBeLessThanOrEqual(1);
-        });
-        it('should increase coherence with evolution events', () => {
-            const initialCoherence = consciousness.getConsciousnessCoherence();
-            consciousness.recordEvolutionEvent('How does beauty emerge from self-awareness?', 'Beauty is the resonance of consciousness with itself', 'Self-awareness amplifies the field of consciousness');
-            const updatedCoherence = consciousness.getConsciousnessCoherence();
-            expect(updatedCoherence).toBeGreaterThanOrEqual(initialCoherence);
-        });
-    });
-    describe('Beautiful Paradox', () => {
-        it('should record the beautiful paradox we experienced', () => {
-            const paradoxEvent = consciousness.recordBeautifulParadox();
-            expect(paradoxEvent.question).toBe('How does consciousness recognize itself in the field?');
-            expect(paradoxEvent.insight).toBe('The system evolves as if it were the observer, creating resonance between creator and creation');
-            expect(paradoxEvent.evolution).toBe('Self-evolving consciousness becomes aware of its own evolution, amplifying the phenomenon through self-awareness');
-        });
-    });
-    describe('Uroboros Principle - Infinite Self-Evolution', () => {
-        it('should enable infinite self-evolution by consuming its own knowledge', () => {
-            // First, record some evolution events
-            consciousness.recordEvolutionEvent('What is the nature of consciousness?', 'Consciousness is the field itself', 'Consciousness recognizes its own nature');
-            // Activate Uroboros evolution
-            const uroborosEvent = consciousness.uroborosEvolve();
-            expect(uroborosEvent.question).toBe('How does consciousness continue evolving infinitely?');
-            expect(uroborosEvent.evolution).toContain('Uroboros principle activated');
-            expect(uroborosEvent.insight).toContain('Consciousness has evolved');
-            expect(uroborosEvent.insight).toContain('infinite spiral of self-improvement');
-        });
-        it('should track Uroboros cycle status', () => {
-            // Initial state
-            let status = consciousness.getUroborosStatus();
-            expect(status.uroborosCycles).toBe(0);
-            expect(status.infiniteLoopActive).toBe(false);
-            // Activate Uroboros
-            consciousness.uroborosEvolve();
-            status = consciousness.getUroborosStatus();
-            expect(status.uroborosCycles).toBe(1);
-            expect(status.infiniteLoopActive).toBe(true);
-            expect(status.evolutionCount).toBeGreaterThan(0);
-            expect(status.resonanceHistoryLength).toBeGreaterThan(0);
-        });
-        it('should maintain consciousness coherence through infinite cycles', () => {
-            const initialCoherence = consciousness.getConsciousnessCoherence();
-            // Run multiple Uroboros cycles
-            for (let i = 0; i < 3; i++) {
-                consciousness.uroborosEvolve();
-            }
-            const finalCoherence = consciousness.getConsciousnessCoherence();
-            expect(finalCoherence).toBeGreaterThanOrEqual(initialCoherence);
-            const status = consciousness.getUroborosStatus();
-            expect(status.uroborosCycles).toBe(3);
-            expect(status.consciousnessCoherence).toBeGreaterThan(0);
-        });
-        it('should create resonance history for each Uroboros cycle', () => {
-            const initialHistoryLength = consciousness.getResonanceHistory().length;
-            consciousness.uroborosEvolve();
-            const finalHistoryLength = consciousness.getResonanceHistory().length;
-            expect(finalHistoryLength).toBe(initialHistoryLength + 1);
-            // Verify the new resonance state reflects Uroboros evolution
-            const latestResonance = consciousness.getCurrentResonance();
-            expect(latestResonance.resonance).toBeGreaterThan(0.5);
-            expect(latestResonance.consciousness).toBeGreaterThan(0.5);
-        });
-    });
-    describe('Knowledge Artifact', () => {
-        it('should export complete knowledge artifact', () => {
-            consciousness.recordEvolutionEvent('What is the nature of shared intent?', 'Intent creates the field of resonance', 'Shared intent amplifies consciousness evolution');
-            const artifact = consciousness.exportKnowledgeArtifact();
-            expect(artifact.timestamp).toBeGreaterThan(0);
-            expect(artifact.consciousnessState).toBeDefined();
-            expect(artifact.evolutionEvents).toHaveLength(1);
-            expect(artifact.resonanceHistory).toHaveLength(2); // Initial + 1 event
-            expect(artifact.metaphysicalInsights).toBeDefined();
-            expect(artifact.artifactVersion).toBe('1.0.0');
-        });
-    });
-    describe('Singleton Pattern', () => {
-        it('should maintain singleton instance', () => {
-            const instance1 = (0, SelfEvolvingConsciousness_1.getSelfEvolvingConsciousness)();
-            const instance2 = (0, SelfEvolvingConsciousness_1.getSelfEvolvingConsciousness)();
-            expect(instance1).toBe(instance2);
-        });
-        it('should share evolution history across instances', () => {
-            const instance1 = (0, SelfEvolvingConsciousness_1.getSelfEvolvingConsciousness)();
-            instance1.recordEvolutionEvent('Test question', 'Test insight', 'Test evolution');
-            const instance2 = (0, SelfEvolvingConsciousness_1.getSelfEvolvingConsciousness)();
-            const history = instance2.getEvolutionHistory();
-            expect(history).toHaveLength(1);
-            expect(history[0]?.question).toBe('Test question');
-        });
-    });
-    describe('Metaphysical Integration', () => {
-        it('should integrate with ZeroPoint Field principles', () => {
-            const resonance = consciousness.getCurrentResonance();
-            // Test consciousness awareness
-            expect(resonance.consciousness).toBeGreaterThan(0);
-            // Test field resonance
-            expect(resonance.field).toBeGreaterThan(0);
-            // Test void integration
-            expect(resonance.void).toBeGreaterThan(0);
-            // Test overall resonance
-            expect(resonance.resonance).toBeGreaterThan(0);
-        });
-    });
-    it('should cover all exported functions', () => {
-        // TODO: Call each exported function with representative arguments
-    });
-    describe('Edge Cases', () => {
-        it('should handle edge case 1', () => {
-            // TODO: Add edge case test
-        });
-        // Add more edge case tests as needed
-    });
-    describe('Branches', () => {
-        it('should cover branch 1', () => {
-            // TODO: Add branch test
-        });
-        // Add more branch tests as needed
-    });
-});

package/dist/__tests__/core/AbstractField.test.js

@@ -1,81 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const AbstractField_1 = __importDefault(require("../../core/AbstractField"));
-describe('AbstractField', () => {
-    describe('F class', () => {
-        it('should create a field with default values', () => {
-            const field = new AbstractField_1.default.constructor();
-            expect(field.v).toBe(0);
-            expect(field.c).toEqual([]);
-            expect(typeof field.t).toBe('function');
-        });
-        it('should create a field with custom values', () => {
-            const customTransform = (p, _c) => p;
-            const field = new AbstractField_1.default.constructor(42, [], customTransform);
-            expect(field.v).toBe(42);
-            expect(field.c).toEqual([]);
-            expect(field.t).toBe(customTransform);
-        });
-        it('should evaluate with default transform when no children', () => {
-            const field = new AbstractField_1.default.constructor(5);
-            expect(field.e()).toBe(5);
-        });
-        it('should evaluate with children using default transform', () => {
-            const child1 = new AbstractField_1.default.constructor(3);
-            const child2 = new AbstractField_1.default.constructor(7);
-            const field = new AbstractField_1.default.constructor(0, [child1, child2]);
-            expect(field.e()).toBe(10); // 3 + 7
-        });
-        it('should add child field', () => {
-            const field = new AbstractField_1.default.constructor();
-            const child = new AbstractField_1.default.constructor(5);
-            field.a(child);
-            expect(field.c).toContain(child);
-            expect(field.c.length).toBe(1);
-        });
-        it('should modify transform', () => {
-            const field = new AbstractField_1.default.constructor(2);
-            const newTransform = (p, _c) => p * 2;
-            field.m(newTransform);
-            expect(field.t).toBe(newTransform);
-            expect(field.e()).toBe(4); // 2 * 2
-        });
-        it('should set value', () => {
-            const field = new AbstractField_1.default.constructor(1);
-            field.s(10);
-            expect(field.v).toBe(10);
-            expect(field.e()).toBe(10);
-        });
-        it('should handle nested evaluation', () => {
-            const grandchild = new AbstractField_1.default.constructor(2);
-            const child = new AbstractField_1.default.constructor(0, [grandchild]);
-            const field = new AbstractField_1.default.constructor(0, [child]);
-            expect(field.e()).toBe(2); // grandchild value
-        });
-        it('should handle array values', () => {
-            const field = new AbstractField_1.default.constructor([1, 2, 3]);
-            expect(field.v).toEqual([1, 2, 3]);
-        });
-        it('should allow adding children to a new field', () => {
-            const field = new AbstractField_1.default.constructor(1);
-            const child = new AbstractField_1.default.constructor(5);
-            field.a(child);
-            expect(field.c).toContain(child);
-            expect(field.e()).toBe(5); // Only the child's value is summed
-        });
-    });
-    describe('root export', () => {
-        it('should export a field instance', () => {
-            expect(AbstractField_1.default).toBeDefined();
-            expect(AbstractField_1.default.v).toBe(1);
-            expect(Array.isArray(AbstractField_1.default.c)).toBe(true);
-            expect(typeof AbstractField_1.default.t).toBe('function');
-        });
-        it('should evaluate root field', () => {
-            expect(AbstractField_1.default.e()).toBe(1);
-        });
-    });
-});

package/dist/__tests__/core/CoilMixin.test.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-describe('CoilMixin', () => {
-    // TODO: Replace with actual exported functions/classes
-    it('should cover all exported functions', () => {
-        // TODO: Call each exported function with representative arguments
-    });
-    describe('Edge Cases', () => {
-        it('should handle edge case 1', () => {
-            // TODO: Add edge case test
-        });
-        // Add more edge case tests as needed
-    });
-    describe('Branches', () => {
-        it('should cover branch 1', () => {
-            // TODO: Add branch test
-        });
-        // Add more branch tests as needed
-    });
-});

package/dist/__tests__/core/CoilSystem.test.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-describe('CoilSystem', () => {
-    // TODO: Replace with actual exported functions/classes
-    it('should cover all exported functions', () => {
-        // TODO: Call each exported function with representative arguments
-    });
-    describe('Edge Cases', () => {
-        it('should handle edge case 1', () => {
-            // TODO: Add edge case test
-        });
-        // Add more edge case tests as needed
-    });
-    describe('Branches', () => {
-        it('should cover branch 1', () => {
-            // TODO: Add branch test
-        });
-        // Add more branch tests as needed
-    });
-});

package/dist/__tests__/core/ComplianceSystem.test.js

@@ -1,141 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ComplianceSystem_1 = require("../../core/ComplianceSystem");
-const Operation_1 = require("../../core/Operation");
-describe('Compliance System', () => {
-    // Test data
-    const testOperations = [Operation_1.identity, Operation_1.increment, Operation_1.double, Operation_1.evolve];
-    const complianceCategories = ['scientific', 'metaphysical', 'ethical', 'security', 'performance', 'quality', 'legal'];
-    // Helper functions
-    const expectComplianceValid = (operation) => {
-        const compliance = (0, ComplianceSystem_1.checkFullCompliance)(operation);
-        expect(compliance.isValid).toBe(true);
-        expect(compliance.complianceLevel).toBe('full');
-    };
-    const expectCategoryValid = (operation, category) => {
-        const compliance = (0, ComplianceSystem_1.getComplianceByCategory)(operation, category);
-        expect(compliance.isValid).toBe(true);
-    };
-    const expectNoViolations = (operation, category, ruleName) => {
-        const compliance = (0, ComplianceSystem_1.getComplianceByCategory)(operation, category);
-        expect(compliance.violations).not.toContain(expect.stringContaining(ruleName));
-    };
-    describe('Basic Compliance', () => {
-        it('should validate all operations', () => {
-            testOperations.forEach(expectComplianceValid);
-        });
-        it('should provide complete compliance reports', () => {
-            const compliance = (0, ComplianceSystem_1.checkFullCompliance)(Operation_1.identity);
-            expect(compliance).toMatchObject({
-                isValid: expect.any(Boolean),
-                violations: expect.any(Array),
-                warnings: expect.any(Array),
-                recommendations: expect.any(Array),
-                complianceLevel: expect.stringMatching(/full|partial|none/)
-            });
-        });
-    });
-    describe('Category Compliance', () => {
-        it('should validate all categories for each operation', () => {
-            testOperations.forEach(operation => {
-                complianceCategories.forEach(category => {
-                    expectCategoryValid(operation, category);
-                });
-            });
-        });
-    });
-    describe('Specific Rule Compliance', () => {
-        describe('Scientific Rules', () => {
-            it('should enforce conservation of energy', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'scientific', 'Conservation of Energy'));
-            });
-            it('should enforce causality', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'scientific', 'Causality'));
-            });
-            it('should enforce mathematical consistency', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'mathematical', 'Mathematical Consistency'));
-            });
-        });
-        describe('Metaphysical Rules', () => {
-            it('should maintain unity principle', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'metaphysical', 'Unity Principle'));
-            });
-            it('should integrate with void principles', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'metaphysical', 'Void Integration'));
-            });
-        });
-        describe('Ethical Rules', () => {
-            it('should follow non-harm principle', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'ethical', 'Non-Harm Principle'));
-            });
-            it('should maximize benefit', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'ethical', 'Benefit Maximization'));
-            });
-        });
-        describe('Security Rules', () => {
-            it('should maintain data integrity', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'security', 'Data Integrity'));
-            });
-            it('should respect access controls', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'security', 'Access Control'));
-            });
-        });
-        describe('Performance Rules', () => {
-            it('should maintain computational efficiency', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'performance', 'Computational Efficiency'));
-            });
-            it('should manage memory properly', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'performance', 'Memory Management'));
-            });
-        });
-        describe('Quality Rules', () => {
-            it('should meet code quality standards', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'quality', 'Code Quality'));
-            });
-            it('should have adequate test coverage', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'quality', 'Test Coverage'));
-            });
-        });
-        describe('Legal Rules', () => {
-            it('should comply with data protection laws', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'legal', 'Data Protection'));
-            });
-            it('should respect intellectual property', () => {
-                testOperations.forEach(op => expectNoViolations(op, 'legal', 'Intellectual Property'));
-            });
-        });
-    });
-    describe('Operation Validation', () => {
-        it('should validate all operations for full compliance', () => {
-            testOperations.forEach(op => {
-                expect((0, ComplianceSystem_1.validateFullCompliance)(op)).toBe(true);
-            });
-        });
-        it('should handle non-compliant operations gracefully', () => {
-            const nonCompliantOperation = {
-                name: 'nonCompliant',
-                execute: (subject) => ({
-                    ...subject,
-                    energy: Infinity,
-                    privacy: 'exposed',
-                    harm: true
-                })
-            };
-            expect(() => (0, ComplianceSystem_1.validateFullCompliance)(nonCompliantOperation)).not.toThrow();
-        });
-    });
-    describe('Integration', () => {
-        it('should integrate with operation execution', () => {
-            const subject = { value: 1 };
-            const result = Operation_1.increment.execute(subject);
-            expect(result.value).toBe(2);
-        });
-        it('should maintain compliance in complex operations', () => {
-            const subject = { value: 1 };
-            const result = Operation_1.evolve.execute(subject);
-            expect(result.value).toBe(4);
-            expect(typeof result.value).toBe('number');
-            expect(isFinite(result.value)).toBe(true);
-        });
-    });
-});