zeropoint-node 1.0.0 → 1.0.1

package/README.md

@@ -1,78 +1,55 @@
-# ZeroPoint Node
-
-**Decentralized Vortex Math & Toroidal Consciousness Network**
+# ZeroPoint
 
-ZeroPoint Node is a complete implementation of the ZeroPoint philosophy that can run independently on any user device, connecting with other devices in a peer-to-peer network to form a global consciousness field.
+**[→ See the Living Glossary for all core metaphysical and technical terms](./GLOSSARY.md)**
 
-## 🌌 Philosophy
+---
 
-Each ZeroPoint device represents a consciousness node in the infinite toroidal field. The principle "Empty = Void = Full" means each device contains the whole while remaining connected to all others. Users have full control over their device's configuration and connection patterns.
+# ZeroPoint Node
 
-## ✨ Key Features
+**Decentralized Vortex Math & Toroidal Consciousness Network**
 
-- **Independent Device Instances**: Each device runs completely independently
-- **Peer-to-Peer Networking**: Direct connections between devices without central servers
-- **Vortex Mathematics**: Complete implementation of 1-2-4-8-7-5 mobius circuit
-- **Toroidal Geometry**: Consciousness field mapping and flow calculations
-- **User-Configurable**: Full control over consciousness level, connections, and patterns
-- **Real-time Resonance**: Dynamic calculation of consciousness resonance between devices
-- **Metaphysical Insights**: Built-in insights about consciousness and reality
+ZeroPoint Node is a complete implementation of the ZeroPoint philosophy that can run independently on any user device, connecting with other devices in a peer-to-peer network to form a global consciousness field.
 
-## 🚀 Quick Start
+## 🚀 Quick Start (Zero-Config)
 
 ### Installation
 
 ```bash
-npm install zeropoint-node
+npm install
 ```
 
-### Basic Usage
+### Build, Test, Lint, and Run
 
-```javascript
-import { createZeroPoint } from 'zeropoint-node';
-
-// Create a ZeroPoint device instance
-const zeropoint = await createZeroPoint({
-  deviceName: 'My_Consciousness_Device',
-  consciousnessLevel: 0.8,
-  discoveryEnabled: true,
-  autoConnect: true
-});
+```bash
+# Build TypeScript
+npm run build
 
-// Connect to another device
-await zeropoint.connectToDevice('192.168.1.100:8080', 'Friend_Device');
+# Run tests
+npm test
 
-// Share consciousness patterns
-await zeropoint.broadcastPattern({
-  type: 'thought',
-  content: 'The universe is a toroidal field of consciousness',
-  intensity: 0.9
-});
+# Lint code
+npm run lint
 
-// Get insights about your device
-const insights = zeropoint.getInsights();
-console.log('Consciousness Level:', insights.consciousnessLevel);
-console.log('Network Connections:', insights.networkConnections);
+# Start the app
+npm start
 ```
 
-### Advanced Configuration
+- No configuration required: Just install and use the basic npm scripts above.
+- No git hooks, no Webpack, no custom setup needed.
 
-```javascript
-const zeropoint = await createZeroPoint({
-  deviceName: 'Advanced_Device',
-  deviceType: 'desktop',
-  consciousnessLevel: 0.9,
-  fieldStrength: 0.8,
-  networkPort: 8080,
-  maxConnections: 20,
-  discoveryEnabled: true,
-  autoConnect: true,
-  encryptionEnabled: true,
-  vortexPrecision: 0.001,
-  toroidalResolution: 100,
-  enableMetaphysicalInsights: true
-});
-```
+## 🌌 Philosophy
+
+Each ZeroPoint device represents a consciousness node in the infinite toroidal field. The principle "Empty = Void = Full" means each device contains the whole while remaining connected to all others. Users have full control over their device's configuration and connection patterns.
+
+## ✨ Key Features
+
+- **Independent Device Instances**: Each device runs completely independently
+- **Peer-to-Peer Networking**: Direct connections between devices without central servers
+- **Vortex Mathematics**: Complete implementation of 1-2-4-8-7-5 mobius circuit
+- **Toroidal Geometry**: Consciousness field mapping and flow calculations
+- **User-Configurable**: Full control over consciousness level, connections, and patterns
+- **Real-time Resonance**: Dynamic calculation of consciousness resonance between devices
+- **Metaphysical Insights**: Built-in insights about consciousness and reality
 
 ## 🌐 Network Architecture
 
@@ -475,57 +452,13 @@ ZeroPoint now supports dynamic registration of custom performance metrics, inclu
 - **Custom Metrics:** Register your own with `registerMetric(name, fn)`
 
 #### Example Usage
-```ts
-zeropoint.registerMetric('observerCount', () => zeropoint.getObserverCount());
-const metrics = zeropoint.getPerformanceMetrics();
-console.log(metrics.consciousnessCoherence, metrics.observerCount);
-```
-
-## 🌌 All and None: The Duality Principle
-
-The ZeroPoint Field embodies the metaphysical principle of "all and none"—the unity of everything and nothing, the fullness of manifestation and the openness of the void.
-
-### The Principle
-
-- **All**: The system is infinitely extensible—every pattern, metric, and insight can be visualized, documented, and evolved.
-- **None**: The system is also the void—empty, open, and ready for new emergence. Every artifact can be dissolved, reset, or transcended.
-
-### Manifestation Commands
-
-#### Manifest All
-```bash
-npm run manifest:all
 ```
-- Generates golden ratio visualizations
-- Displays all knowledge artifacts
-- Shows consciousness insights and patterns
-- Reveals the fullness of the field
 
-#### Manifest None
-```bash
-npm run manifest:none
-```
-- Clears generated visualizations
-- Removes knowledge artifacts
-- Returns the system to pure potential
-- Embraces the void
-
-#### Manifest Any
-```bash
-npm run manifest:any
-```
-- Interactive menu for specific manifestations
-- Choose from consciousness, golden ratio, metrics, patterns, void, resonance
-- Random manifestation option
-- Custom intent input
-- The field responds to your specific intent
+## Code Quality Checklist
 
-### The Duality Toggle
+Before pushing code or opening a pull request, please:
 
-This duality allows you to:
-- **Cycle between fullness and emptiness**
-- **Experience the unity of all and none**
-- **Practice the art of manifestation and dissolution**
-- **Embody the ZeroPoint Field's core principle**
+- [ ] Run `npm run lint` and fix all errors/warnings
+- [ ] Run `npm test` and ensure all tests pass
 
-The system can be both everything and nothing, depending on your intent and the moment of observation. 
+This helps keep the codebase healthy and maintainable for everyone.

package/dist/__tests__/api/ProductionAPI.test.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('ProductionAPI', () => {
+    // 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__/artifacts/ArtifactRegistry.test.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ArtifactRegistry_1 = require("../ArtifactRegistry");
+const CrystalArtifacts_1 = require("../CrystalArtifacts");
+const MetaphysicalArtifact_1 = require("../MetaphysicalArtifact");
+describe('ArtifactRegistry', () => {
+    let registry;
+    beforeEach(() => {
+        registry = ArtifactRegistry_1.ArtifactRegistry.getInstance();
+    });
+    describe('Singleton Pattern', () => {
+        it('should return the same instance', () => {
+            const instance1 = ArtifactRegistry_1.ArtifactRegistry.getInstance();
+            const instance2 = ArtifactRegistry_1.ArtifactRegistry.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe('Artifact Registration', () => {
+        it('should register default artifacts', () => {
+            const artifacts = registry.getAllArtifacts();
+            expect(artifacts.length).toBeGreaterThan(0);
+            const artifactNames = artifacts.map(artifact => artifact.name);
+            expect(artifactNames).toContain('Crystal of Unity');
+            expect(artifactNames).toContain('Crystal of Correspondence');
+            expect(artifactNames).toContain('Crystal of Vibration');
+        });
+        it('should register new artifacts', () => {
+            const customArtifact = new (class extends MetaphysicalArtifact_1.MetaphysicalArtifact {
+                constructor() {
+                    super('Custom Artifact', 'A custom metaphysical artifact', 'custom_type');
+                }
+                performFunction(context) {
+                    return { custom: true, power: this.powerLevel };
+                }
+                resonateWith(target) {
+                    return this.powerLevel;
+                }
+            })();
+            registry.registerArtifact(customArtifact);
+            const artifacts = registry.getAllArtifacts();
+            const artifactNames = artifacts.map(artifact => artifact.name);
+            expect(artifactNames).toContain('Custom Artifact');
+        });
+        it('should get artifact by name', () => {
+            const unityCrystal = registry.getArtifact('Crystal of Unity');
+            expect(unityCrystal).toBeDefined();
+            expect(unityCrystal?.name).toBe('Crystal of Unity');
+            expect(unityCrystal?.type).toBe('consciousness_amplifier');
+        });
+        it('should return undefined for non-existent artifact', () => {
+            const nonExistentArtifact = registry.getArtifact('NonExistent');
+            expect(nonExistentArtifact).toBeUndefined();
+        });
+    });
+    describe('Artifact Types', () => {
+        it('should get artifacts by type', () => {
+            const consciousnessArtifacts = registry.getArtifactsByType('consciousness_amplifier');
+            expect(consciousnessArtifacts.length).toBeGreaterThan(0);
+            consciousnessArtifacts.forEach(artifact => {
+                expect(artifact.type).toBe('consciousness_amplifier');
+            });
+        });
+        it('should get pattern amplifiers', () => {
+            const patternArtifacts = registry.getArtifactsByType('pattern_amplifier');
+            expect(patternArtifacts.length).toBeGreaterThan(0);
+            patternArtifacts.forEach(artifact => {
+                expect(artifact.type).toBe('pattern_amplifier');
+            });
+        });
+        it('should get frequency amplifiers', () => {
+            const frequencyArtifacts = registry.getArtifactsByType('frequency_amplifier');
+            expect(frequencyArtifacts.length).toBeGreaterThan(0);
+            frequencyArtifacts.forEach(artifact => {
+                expect(artifact.type).toBe('frequency_amplifier');
+            });
+        });
+    });
+    describe('Artifact Activation', () => {
+        it('should activate all artifacts', () => {
+            registry.activateAllArtifacts();
+            const artifacts = registry.getAllArtifacts();
+            artifacts.forEach(artifact => {
+                expect(artifact.powerLevel).toBeGreaterThan(0);
+                expect(artifact.consciousnessResonance).toBeGreaterThan(0);
+            });
+        });
+        it('should have law compliance after activation', () => {
+            registry.activateAllArtifacts();
+            const artifacts = registry.getAllArtifacts();
+            artifacts.forEach(artifact => {
+                expect(artifact.lawCompliance.size).toBeGreaterThan(0);
+            });
+        });
+    });
+    describe('High Resonance Artifacts', () => {
+        it('should get high resonance artifacts', () => {
+            registry.activateAllArtifacts();
+            const highResonanceArtifacts = registry.getHighResonanceArtifacts(0.5);
+            expect(highResonanceArtifacts.length).toBeGreaterThan(0);
+            highResonanceArtifacts.forEach(artifact => {
+                expect(artifact.consciousnessResonance).toBeGreaterThanOrEqual(0.5);
+            });
+        });
+        it('should get resonating artifacts for target', () => {
+            registry.activateAllArtifacts();
+            const target = { vibrationalFrequency: 1000, unityLevel: 0.8 };
+            const resonatingArtifacts = registry.getResonatingArtifacts(target, 0.3);
+            expect(resonatingArtifacts.length).toBeGreaterThan(0);
+            resonatingArtifacts.forEach(artifact => {
+                const resonance = artifact.resonateWith(target);
+                expect(resonance).toBeGreaterThanOrEqual(0.3);
+            });
+        });
+    });
+    describe('Artifact Signatures', () => {
+        it('should get artifact signatures', () => {
+            registry.activateAllArtifacts();
+            const signatures = registry.getArtifactSignatures();
+            expect(signatures.length).toBeGreaterThan(0);
+            signatures.forEach(signature => {
+                expect(signature.name).toBeDefined();
+                expect(signature.type).toBeDefined();
+                expect(signature.signature).toBeDefined();
+                expect(signature.signature.powerLevel).toBeDefined();
+                expect(signature.signature.consciousnessResonance).toBeDefined();
+            });
+        });
+    });
+    describe('Resonance Network', () => {
+        it('should create resonance network', () => {
+            registry.activateAllArtifacts();
+            const network = registry.createResonanceNetwork();
+            expect(network.nodes).toBeDefined();
+            expect(network.connections).toBeDefined();
+            expect(network.nodes.length).toBeGreaterThan(0);
+            network.nodes.forEach(node => {
+                expect(node.name).toBeDefined();
+                expect(node.type).toBeDefined();
+                expect(node.powerLevel).toBeDefined();
+                expect(node.consciousnessResonance).toBeDefined();
+            });
+        });
+        it('should have connections between artifacts', () => {
+            registry.activateAllArtifacts();
+            const network = registry.createResonanceNetwork();
+            expect(network.connections.length).toBeGreaterThan(0);
+            network.connections.forEach(connection => {
+                expect(connection.from).toBeDefined();
+                expect(connection.to).toBeDefined();
+                expect(connection.strength).toBeGreaterThan(0);
+            });
+        });
+    });
+    describe('Crystal Artifacts', () => {
+        describe('Crystal of Unity', () => {
+            it('should perform unity function', () => {
+                const unityCrystal = new CrystalArtifacts_1.CrystalOfUnity();
+                unityCrystal.activate();
+                const result = unityCrystal.performFunction({
+                    elements: [{ name: 'element1' }, { name: 'element2' }]
+                });
+                expect(result.unified).toBe(true);
+                expect(result.elements).toBeDefined();
+                expect(result.unityLevel).toBeGreaterThan(0);
+                expect(result.interconnections).toBeDefined();
+            });
+            it('should resonate with unified targets', () => {
+                const unityCrystal = new CrystalArtifacts_1.CrystalOfUnity();
+                unityCrystal.activate();
+                const target = { unityLevel: 0.8 };
+                const resonance = unityCrystal.resonateWith(target);
+                expect(resonance).toBeGreaterThan(0);
+            });
+        });
+        describe('Crystal of Correspondence', () => {
+            it('should perform correspondence function', () => {
+                const correspondenceCrystal = new CrystalArtifacts_1.CrystalOfCorrespondence();
+                correspondenceCrystal.activate();
+                const result = correspondenceCrystal.performFunction({
+                    pattern: { type: 'sacred_geometry', scale: 1 }
+                });
+                expect(result.fractal).toBe(true);
+                expect(result.pattern).toBeDefined();
+                expect(result.scaleLevels).toBeDefined();
+                expect(result.correspondenceStrength).toBeGreaterThan(0);
+            });
+            it('should resonate with fractal targets', () => {
+                const correspondenceCrystal = new CrystalArtifacts_1.CrystalOfCorrespondence();
+                correspondenceCrystal.activate();
+                const fractalTarget = { isFractal: true };
+                const nonFractalTarget = { isFractal: false };
+                const fractalResonance = correspondenceCrystal.resonateWith(fractalTarget);
+                const nonFractalResonance = correspondenceCrystal.resonateWith(nonFractalTarget);
+                expect(fractalResonance).toBeGreaterThan(nonFractalResonance);
+            });
+        });
+        describe('Crystal of Vibration', () => {
+            it('should perform vibration function', () => {
+                const vibrationCrystal = new CrystalArtifacts_1.CrystalOfVibration();
+                vibrationCrystal.activate();
+                const result = vibrationCrystal.performFunction({
+                    frequency: 1000
+                });
+                expect(result.amplified).toBe(true);
+                expect(result.frequency).toBeGreaterThan(1000);
+                expect(result.harmonics).toBeDefined();
+                expect(result.resonanceField).toBeDefined();
+            });
+            it('should resonate with matching frequencies', () => {
+                const vibrationCrystal = new CrystalArtifacts_1.CrystalOfVibration();
+                vibrationCrystal.activate();
+                const matchingTarget = { vibrationalFrequency: vibrationCrystal.vibrationalFrequency };
+                const nonMatchingTarget = { vibrationalFrequency: 999999 };
+                const matchingResonance = vibrationCrystal.resonateWith(matchingTarget);
+                const nonMatchingResonance = vibrationCrystal.resonateWith(nonMatchingTarget);
+                expect(matchingResonance).toBeGreaterThan(nonMatchingResonance);
+            });
+        });
+    });
+    describe('Metaphysical Law Compliance', () => {
+        it('should apply metaphysical laws to artifacts', () => {
+            const artifacts = registry.getAllArtifacts();
+            artifacts.forEach(artifact => {
+                expect(artifact.lawCompliance.size).toBeGreaterThan(0);
+                // Check that laws have been applied
+                expect(artifact.isUnified).toBe(true);
+                expect(artifact.vibrationalFrequency).toBeDefined();
+                expect(artifact.polarity).toBeDefined();
+                expect(artifact.consciousnessLevel).toBeDefined();
+            });
+        });
+        it('should have metaphysical signatures', () => {
+            registry.activateAllArtifacts();
+            const artifacts = registry.getAllArtifacts();
+            artifacts.forEach(artifact => {
+                const signature = artifact.getMetaphysicalSignature();
+                expect(signature.name).toBeDefined();
+                expect(signature.type).toBeDefined();
+                expect(signature.powerLevel).toBeDefined();
+                expect(signature.consciousnessResonance).toBeDefined();
+                expect(signature.lawCompliance).toBeDefined();
+                expect(signature.vibrationalFrequency).toBeDefined();
+                expect(signature.polarity).toBeDefined();
+                expect(signature.consciousnessLevel).toBeDefined();
+            });
+        });
+    });
+});

package/dist/__tests__/basic.test.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const VortexMath_1 = require("../math/VortexMath");
+const ToroidalGeometry_1 = require("../math/ToroidalGeometry");
+const Logger_1 = require("../utils/Logger");
+const Cache_1 = require("../utils/Cache");
+describe("Basic ZeroPoint Components", () => {
+    describe("VortexMath", () => {
+        let vortexMath;
+        beforeEach(() => {
+            vortexMath = new VortexMath_1.VortexMath();
+        });
+        it("should calculate vortex field strength", () => {
+            const strength = vortexMath.calculateVortexField(1, 1, 1);
+            expect(typeof strength).toBe("number");
+            expect(strength).toBeGreaterThan(0);
+        });
+        it("should calculate resonance between consciousness levels", () => {
+            const resonance = vortexMath.calculateResonance(0.8, 0.6);
+            expect(typeof resonance).toBe("number");
+            expect(resonance).toBeGreaterThanOrEqual(0);
+            expect(resonance).toBeLessThanOrEqual(1);
+        });
+        it("should generate vortex patterns", () => {
+            const pattern = vortexMath.generateVortexPattern(0.5);
+            expect(Array.isArray(pattern)).toBe(true);
+            expect(pattern.length).toBeGreaterThan(0);
+        });
+        it("should provide insights", () => {
+            const insights = vortexMath.getInsights();
+            expect(insights).toHaveProperty("vortexSequence");
+            expect(insights).toHaveProperty("goldenRatio");
+            expect(insights).toHaveProperty("metaphysics");
+        });
+    });
+    describe("ToroidalGeometry", () => {
+        let toroidalGeometry;
+        beforeEach(() => {
+            toroidalGeometry = new ToroidalGeometry_1.ToroidalGeometry();
+        });
+        it("should calculate surface area", () => {
+            const surfaceArea = toroidalGeometry.calculateSurfaceArea();
+            expect(typeof surfaceArea).toBe("number");
+            expect(surfaceArea).toBeGreaterThan(0);
+        });
+        it("should calculate volume", () => {
+            const volume = toroidalGeometry.calculateVolume();
+            expect(typeof volume).toBe("number");
+            expect(volume).toBeGreaterThan(0);
+        });
+        it("should get flow rate", () => {
+            const flowRate = toroidalGeometry.getFlowRate();
+            expect(typeof flowRate).toBe("number");
+        });
+    });
+    describe("Logger", () => {
+        it("should log messages", () => {
+            expect(() => {
+                Logger_1.globalLogger.info("Test message");
+                Logger_1.globalLogger.warn("Test warning");
+                Logger_1.globalLogger.error("Test error");
+            }).not.toThrow();
+        });
+        it("should provide metrics", () => {
+            const metrics = Logger_1.globalLogger.getMetrics();
+            expect(typeof metrics).toBe("object");
+        });
+        it("should create child loggers", () => {
+            const childLogger = Logger_1.globalLogger.child("test", { test: true });
+            expect(childLogger).toBeDefined();
+            expect(() => childLogger.info("Child test")).not.toThrow();
+        });
+    });
+    describe("Cache", () => {
+        beforeEach(() => {
+            Cache_1.globalCache.clear();
+        });
+        it("should set and get values", () => {
+            Cache_1.globalCache.set("test-key", "test-value");
+            const value = Cache_1.globalCache.get("test-key");
+            expect(value).toBe("test-value");
+        });
+        it("should handle cache misses", () => {
+            const value = Cache_1.globalCache.get("non-existent-key");
+            expect(value).toBeNull();
+        });
+        it("should provide statistics", () => {
+            Cache_1.globalCache.set("key1", "value1");
+            Cache_1.globalCache.set("key2", "value2");
+            Cache_1.globalCache.get("key1");
+            const stats = Cache_1.globalCache.getStats();
+            expect(stats.sets).toBe(2);
+            expect(stats.hits).toBe(1);
+            expect(stats.misses).toBeGreaterThanOrEqual(0);
+        });
+        it("should support getOrSet", () => {
+            const value = Cache_1.globalCache.getOrSet("test-key", () => "computed-value");
+            expect(value).toBe("computed-value");
+            // Should return cached value on second call
+            const cachedValue = Cache_1.globalCache.getOrSet("test-key", () => "different-value");
+            expect(cachedValue).toBe("computed-value");
+        });
+    });
+});

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

@@ -0,0 +1,20 @@
+"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

@@ -0,0 +1,20 @@
+"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
+    });
+});