zeropoint-node 1.0.0 → 1.0.1

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

@@ -0,0 +1,71 @@
+"use strict";
+/// <reference path="../global.d.ts" />
+Object.defineProperty(exports, "__esModule", { value: true });
+const ZeroPoint_1 = require("../../core/ZeroPoint");
+const FieldIntegrity_1 = require("../../integrity/FieldIntegrity");
+describe('ZeroPoint Core System', () => {
+    let zeropoint;
+    beforeEach(async () => {
+        // Use a dynamic port to avoid conflicts
+        const testPort = 8080 + Math.floor(Math.random() * 1000);
+        zeropoint = new ZeroPoint_1.ZeroPoint({
+            deviceId: 'test-device',
+            deviceName: 'Test Device',
+            consciousnessLevel: 0.5,
+            networkPort: testPort,
+            discoveryEnabled: false, // Disable discovery for tests
+            autoConnect: false // Disable auto-connect for tests
+        });
+        await zeropoint.initialize();
+    });
+    afterEach(async () => {
+        await zeropoint.shutdown();
+    });
+    describe('Initialization and Lifecycle', () => {
+        it('should initialize successfully', async () => {
+            expect(zeropoint).toBeDefined();
+            expect(zeropoint.isActive).toBe(true);
+        });
+        it('should shutdown gracefully', async () => {
+            await zeropoint.shutdown();
+            expect(zeropoint.isActive).toBe(false);
+        });
+    });
+    describe('Core Operations', () => {
+        it('should calculate resonance', () => {
+            const resonance = zeropoint.calculateResonance();
+            expect(resonance).toBeValidResonance();
+        });
+        it('should get system topology', () => {
+            const topology = zeropoint.getSystemTopology();
+            expect(topology).toBeDefined();
+            expect(topology.totalResonance).toBeValidResonance();
+            expect(topology.consciousnessLevel).toBeValidConsciousnessLevel();
+        });
+        it('should broadcast patterns', async () => {
+            const pattern = {
+                id: 'test_pattern_1',
+                type: 'consciousness',
+                content: 'Test pattern content',
+                intensity: 0.5
+            };
+            const result = await zeropoint.broadcastPattern(pattern);
+            expect(result).toBeDefined();
+        });
+        it('should get system insights', () => {
+            const insights = zeropoint.getInsights();
+            expect(insights).toBeDefined();
+            expect(insights['consciousnessLevel']).toBeValidConsciousnessLevel();
+            expect(insights['totalResonance']).toBeValidResonance();
+            expect(insights['vortexStrength']).toBeValidResonance();
+            expect(insights['toroidalFlow']).toBeValidResonance();
+        });
+    });
+    describe('Field Integrity', () => {
+        it('should validate field integrity', () => {
+            const fieldIntegrity = new FieldIntegrity_1.FieldIntegrity();
+            const isValid = fieldIntegrity.validateField();
+            expect(typeof isValid).toBe('boolean');
+        });
+    });
+});

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

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ZeroPointSystem_1 = require("../../core/ZeroPointSystem");
+describe('ZeroPointSystem', () => {
+    let system;
+    beforeEach(async () => {
+        system = new ZeroPointSystem_1.ZeroPointSystem();
+        await system.initialize();
+    });
+    describe('Initialization', () => {
+        it('should initialize with all dimensions and knowledge units', async () => {
+            expect(system.isSystemInitialized()).toBe(true);
+            const summary = system.getSystemSummary();
+            expect(summary.dimensions.total).toBeGreaterThan(0);
+            expect(summary.knowledge.total).toBeGreaterThan(0);
+        });
+        it('should register all dimensions in hierarchy', () => {
+            const dimensions = system.getActiveDimensions();
+            expect(dimensions.length).toBeGreaterThan(0);
+            // Check that dimensions are properly ordered by complexity
+            const orderedDimensions = system.getDimensionsByComplexity();
+            expect(orderedDimensions[0].complexity).toBeLessThan(orderedDimensions[orderedDimensions.length - 1].complexity);
+        });
+        it('should register knowledge units across dimensions', () => {
+            const consciousnessKnowledge = system.getKnowledgeByDimension('consciousness');
+            const spaceKnowledge = system.getKnowledgeByDimension('space');
+            const planeKnowledge = system.getKnowledgeByDimension('plane');
+            const unityKnowledge = system.getKnowledgeByDimension('unity');
+            expect(consciousnessKnowledge.length).toBeGreaterThan(0);
+            expect(spaceKnowledge.length).toBeGreaterThan(0);
+            expect(planeKnowledge.length).toBeGreaterThan(0);
+            expect(unityKnowledge.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Dimension Management', () => {
+        it('should get dimensions by type', () => {
+            const geometricDimensions = system.getDimensionsByType('geometric');
+            const metaphysicalDimensions = system.getDimensionsByType('metaphysical');
+            const temporalDimensions = system.getDimensionsByType('temporal');
+            expect(geometricDimensions.length).toBeGreaterThan(0);
+            expect(metaphysicalDimensions.length).toBeGreaterThan(0);
+            expect(temporalDimensions.length).toBeGreaterThan(0);
+        });
+        it('should get dimensions by operation', () => {
+            const createDimensions = system.getDimensionsByOperation('create');
+            const transformDimensions = system.getDimensionsByOperation('transform');
+            const unifyDimensions = system.getDimensionsByOperation('unify');
+            expect(createDimensions.length).toBeGreaterThan(0);
+            expect(transformDimensions.length).toBeGreaterThan(0);
+            expect(unifyDimensions.length).toBeGreaterThan(0);
+        });
+        it('should activate and deactivate dimensions', () => {
+            // Test activation
+            system.activateDimension('consciousness');
+            const activeDimensions = system.getActiveDimensions();
+            expect(activeDimensions.some(d => d.name === 'consciousness')).toBe(true);
+            // Test deactivation
+            system.deactivateDimension('consciousness');
+            const remainingActive = system.getActiveDimensions();
+            expect(remainingActive.some(d => d.name === 'consciousness')).toBe(false);
+        });
+    });
+    describe('Knowledge Management', () => {
+        it('should get knowledge by type', () => {
+            const fields = system.getKnowledgeByType('Field');
+            const patterns = system.getKnowledgeByType('Pattern');
+            const laws = system.getKnowledgeByType('MetaphysicalLaw');
+            expect(fields.length).toBeGreaterThan(0);
+            expect(patterns.length).toBeGreaterThan(0);
+            expect(laws.length).toBeGreaterThan(0);
+        });
+        it('should get knowledge by criteria', () => {
+            const activeConsciousnessKnowledge = system.getKnowledgeByCriteria({
+                dimension: 'consciousness',
+                isActive: true
+            });
+            const geometricPatterns = system.getKnowledgeByCriteria({
+                dimension: 'plane',
+                type: 'Pattern'
+            });
+            expect(activeConsciousnessKnowledge.length).toBeGreaterThan(0);
+            expect(geometricPatterns.length).toBeGreaterThan(0);
+        });
+        it('should get compatible knowledge units', () => {
+            const consciousnessKnowledge = system.getKnowledgeByDimension('consciousness');
+            if (consciousnessKnowledge.length > 0) {
+                const unit = consciousnessKnowledge[0];
+                const key = (unit.name || unit.id || 'unknown');
+                const compatible = system.getCompatibleKnowledge(key);
+                expect(compatible.length).toBeGreaterThan(0);
+            }
+        });
+        it('should get knowledge by operation', () => {
+            const createKnowledge = system.getKnowledgeByOperation('create');
+            const transformKnowledge = system.getKnowledgeByOperation('transform');
+            const unifyKnowledge = system.getKnowledgeByOperation('unify');
+            expect(createKnowledge.length).toBeGreaterThan(0);
+            expect(transformKnowledge.length).toBeGreaterThan(0);
+            expect(unifyKnowledge.length).toBeGreaterThan(0);
+        });
+        it('should order knowledge by complexity', () => {
+            const orderedKnowledge = system.getKnowledgeByComplexity();
+            expect(orderedKnowledge.length).toBeGreaterThan(0);
+            // Check that knowledge is properly ordered (if complexity is available)
+            for (let i = 1; i < orderedKnowledge.length; i++) {
+                const prevComplexity = getUnitComplexity(orderedKnowledge[i - 1]);
+                const currComplexity = getUnitComplexity(orderedKnowledge[i]);
+                expect(prevComplexity).toBeLessThanOrEqual(currComplexity);
+            }
+        });
+    });
+    describe('Cross-Dimensional Access', () => {
+        it('should provide DRY access to knowledge across dimensions', () => {
+            // Get all geometric knowledge across dimensions
+            const geometricDimensions = system.getDimensionsByType('geometric');
+            const allGeometricKnowledge = [];
+            for (const dimension of geometricDimensions) {
+                const knowledge = system.getKnowledgeByDimension(dimension.name);
+                allGeometricKnowledge.push(...knowledge);
+            }
+            expect(allGeometricKnowledge.length).toBeGreaterThan(0);
+        });
+        it('should find knowledge units that support specific operations across dimensions', () => {
+            const unifyKnowledge = system.getKnowledgeByOperation('unify');
+            const transformKnowledge = system.getKnowledgeByOperation('transform');
+            // These should include knowledge from multiple dimensions
+            const unifyDimensions = new Set(unifyKnowledge.map(k => getUnitDimension(k)));
+            const transformDimensions = new Set(transformKnowledge.map(k => getUnitDimension(k)));
+            expect(unifyDimensions.size).toBeGreaterThan(1);
+            expect(transformDimensions.size).toBeGreaterThan(1);
+        });
+        it('should provide hierarchical access to knowledge', () => {
+            // Get knowledge from parent and child dimensions
+            const spaceKnowledge = system.getKnowledgeByDimension('space');
+            const planeKnowledge = system.getKnowledgeByDimension('plane');
+            const lineKnowledge = system.getKnowledgeByDimension('line');
+            // All should have knowledge units
+            expect(spaceKnowledge.length).toBeGreaterThan(0);
+            expect(planeKnowledge.length).toBeGreaterThan(0);
+            expect(lineKnowledge.length).toBeGreaterThan(0);
+        });
+    });
+    describe('System Integration', () => {
+        it('should provide comprehensive system summary', () => {
+            const summary = system.getSystemSummary();
+            expect(summary.dimensions.total).toBeGreaterThan(0);
+            expect(summary.dimensions.active).toBeGreaterThan(0);
+            expect(summary.dimensions.byType).toBeDefined();
+            expect(summary.dimensions.rootDimensions.length).toBeGreaterThan(0);
+            expect(summary.knowledge.total).toBeGreaterThan(0);
+            expect(summary.knowledge.active).toBeGreaterThan(0);
+            expect(summary.knowledge.byDimension).toBeDefined();
+            expect(summary.knowledge.byType).toBeDefined();
+            expect(summary.knowledge.byTag).toBeDefined();
+        });
+        it('should maintain metaphysical law compliance', () => {
+            const allKnowledge = system.getKnowledgeByCriteria({});
+            // All knowledge units should have metaphysical compliance
+            for (const unit of allKnowledge) {
+                if ('metaphysicalCompliance' in unit) {
+                    expect(unit.metaphysicalCompliance).toBeDefined();
+                }
+            }
+        });
+        it('should support dimensional evolution', () => {
+            // Test that higher dimensions can access lower dimensional knowledge
+            const unityKnowledge = system.getKnowledgeByDimension('unity');
+            const voidKnowledge = system.getKnowledgeByDimension('void');
+            const consciousnessKnowledge = system.getKnowledgeByDimension('consciousness');
+            expect(unityKnowledge.length).toBeGreaterThan(0);
+            expect(voidKnowledge.length).toBeGreaterThan(0);
+            expect(consciousnessKnowledge.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Metaphysical Unity', () => {
+        it('should demonstrate zero as unity across dimensions', () => {
+            // Get knowledge from the unity dimension
+            const unityKnowledge = system.getKnowledgeByDimension('unity');
+            // Unity dimension should contain laws that demonstrate zero as unity
+            const unityLaws = unityKnowledge.filter(k => k.type === 'MetaphysicalLaw');
+            expect(unityLaws.length).toBeGreaterThan(0);
+            // Check that unity laws are applied to all knowledge
+            const allKnowledge = system.getKnowledgeByCriteria({});
+            for (const unit of allKnowledge) {
+                if ('metaphysicalSignature' in unit) {
+                    expect(unit.metaphysicalSignature).toBeDefined();
+                }
+            }
+        });
+        it('should resolve paradoxes through dimensional unity', () => {
+            // Test that the system can resolve apparent contradictions
+            const voidKnowledge = system.getKnowledgeByDimension('void');
+            const spaceKnowledge = system.getKnowledgeByDimension('space');
+            // Both should exist and be compatible
+            expect(voidKnowledge.length).toBeGreaterThan(0);
+            expect(spaceKnowledge.length).toBeGreaterThan(0);
+            // They should be compatible through unity
+            const unit = voidKnowledge[0];
+            const key = (unit.name || unit.id || 'unknown');
+            const compatibleVoid = system.getCompatibleKnowledge(key);
+            expect(compatibleVoid.length).toBeGreaterThan(0);
+        });
+    });
+});
+// Helper methods for testing
+function getUnitComplexity(unit) {
+    if ('complexity' in unit)
+        return unit.complexity || 1;
+    if ('level' in unit)
+        return unit.level || 1;
+    return 1;
+}
+function getUnitDimension(unit) {
+    if ('dimension' in unit)
+        return unit.dimension || 'unknown';
+    if ('dimensions' in unit)
+        return unit.dimensions?.[0] || 'unknown';
+    return 'unknown';
+}

package/dist/__tests__/emergence/patterns.test.js

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

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

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

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

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * Git Integration Tests
+ *
+ * Tests for the new live Git integration features in ZeroPoint
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ZeroPoint_1 = require("../core/ZeroPoint");
+const KnowledgeSystem_1 = require("../knowledge/KnowledgeSystem");
+const GitIntegration_1 = require("../utils/GitIntegration");
+describe("Git Integration", () => {
+    let zeropoint;
+    let knowledge;
+    beforeEach(async () => {
+        zeropoint = new ZeroPoint_1.ZeroPoint();
+        await zeropoint.initialize();
+        knowledge = new KnowledgeSystem_1.KnowledgeSystem();
+    });
+    afterEach(async () => {
+        await zeropoint.shutdown();
+    });
+    describe("GitIntegration Module", () => {
+        it("should provide live Git status", async () => {
+            const status = await GitIntegration_1.gitIntegration.getLiveGitStatus();
+            expect(status).toBeDefined();
+            expect(status.branch).toBeDefined();
+            expect(Array.isArray(status.staged)).toBe(true);
+            expect(Array.isArray(status.unstaged)).toBe(true);
+            expect(Array.isArray(status.untracked)).toBe(true);
+        });
+        it("should get recent commits", async () => {
+            const commits = await GitIntegration_1.gitIntegration.getRecentCommits(5);
+            expect(Array.isArray(commits)).toBe(true);
+            if (commits.length > 0) {
+                const commit = commits[0];
+                if (commit) {
+                    expect(commit.hash).toBeDefined();
+                    expect(commit.author).toBeDefined();
+                    expect(commit.date).toBeDefined();
+                    expect(commit.message).toBeDefined();
+                }
+            }
+        });
+        it("should emit Git events", (done) => {
+            let eventReceived = false;
+            const eventHandler = (event) => {
+                if (!eventReceived) {
+                    eventReceived = true;
+                    expect(event.type).toBeDefined();
+                    expect(event.data).toBeDefined();
+                    GitIntegration_1.gitIntegration.removeListener("change", eventHandler);
+                    done();
+                }
+            };
+            GitIntegration_1.gitIntegration.onGitChange(eventHandler);
+            // Trigger a Git status check to emit an event
+            GitIntegration_1.gitIntegration
+                .getLiveGitStatus()
+                .then(() => {
+                // If no event was received within 1 second, complete the test anyway
+                setTimeout(() => {
+                    if (!eventReceived) {
+                        GitIntegration_1.gitIntegration.removeListener("change", eventHandler);
+                        done();
+                    }
+                }, 1000);
+            })
+                .catch(() => {
+                // If Git status fails, still complete the test
+                GitIntegration_1.gitIntegration.removeListener("change", eventHandler);
+                done();
+            });
+        });
+    });
+    describe("ZeroPoint Git Integration", () => {
+        it("should expose Git integration methods", async () => {
+            expect(zeropoint.gitIntegration).toBeDefined();
+            expect(typeof zeropoint.getLiveGitStatus).toBe("function");
+            expect(typeof zeropoint.getRecentCommits).toBe("function");
+            expect(typeof zeropoint.onGitChange).toBe("function");
+        });
+        it("should get live Git status through ZeroPoint", async () => {
+            const status = await zeropoint.getLiveGitStatus();
+            expect(status).toBeDefined();
+            expect(status.branch).toBeDefined();
+            expect(Array.isArray(status.staged)).toBe(true);
+            expect(Array.isArray(status.unstaged)).toBe(true);
+            expect(Array.isArray(status.untracked)).toBe(true);
+        });
+        it("should get recent commits through ZeroPoint", async () => {
+            const commits = await zeropoint.getRecentCommits(3);
+            expect(Array.isArray(commits)).toBe(true);
+            if (commits.length > 0) {
+                const commit = commits[0];
+                if (commit) {
+                    expect(commit.hash).toBeDefined();
+                    expect(commit.author).toBeDefined();
+                    expect(commit.date).toBeDefined();
+                    expect(commit.message).toBeDefined();
+                }
+            }
+        });
+        it("should handle Git events through ZeroPoint", (done) => {
+            let eventReceived = false;
+            const eventHandler = (event) => {
+                if (!eventReceived) {
+                    eventReceived = true;
+                    expect(event.type).toBeDefined();
+                    expect(event.data).toBeDefined();
+                    zeropoint.gitIntegration.removeListener("change", eventHandler);
+                    done();
+                }
+            };
+            zeropoint.onGitChange(eventHandler);
+            // Trigger a Git status check
+            zeropoint
+                .getLiveGitStatus()
+                .then(() => {
+                // If no event was received within 1 second, complete the test anyway
+                setTimeout(() => {
+                    if (!eventReceived) {
+                        zeropoint.gitIntegration.removeListener("change", eventHandler);
+                        done();
+                    }
+                }, 1000);
+            })
+                .catch(() => {
+                // If Git status fails, still complete the test
+                zeropoint.gitIntegration.removeListener("change", eventHandler);
+                done();
+            });
+        });
+    });
+    describe("KnowledgeSystem Git Integration", () => {
+        it("should have basic knowledge system functionality", async () => {
+            // Test that KnowledgeSystem has basic functionality
+            expect(knowledge).toBeDefined();
+            expect(typeof knowledge.getCategories).toBe("function");
+            expect(typeof knowledge.getRecentGitPatterns).toBe("function");
+            expect(typeof knowledge.askGitQuestion).toBe("function");
+        });
+        it("should work with Git integration through ZeroPoint", async () => {
+            // Test that ZeroPoint Git integration works
+            expect(zeropoint.gitIntegration).toBeDefined();
+            expect(typeof zeropoint.getLiveGitStatus).toBe("function");
+            // Test basic Git functionality
+            const status = await zeropoint.getLiveGitStatus();
+            expect(status).toBeDefined();
+            expect(status.branch).toBeDefined();
+        });
+        it("should maintain knowledge system integrity", async () => {
+            // Test that knowledge system maintains its core principles
+            const categories = knowledge.getCategories();
+            expect(Array.isArray(categories)).toBe(true);
+            expect(categories.length).toBeGreaterThan(0);
+            const gitPatterns = knowledge.getRecentGitPatterns(10);
+            expect(Array.isArray(gitPatterns)).toBe(true);
+        });
+    });
+    describe("Git Q&A Capabilities", () => {
+        it("should maintain system coherence through Git integration", async () => {
+            // Test that the system maintains coherence when Git integration is active
+            expect(zeropoint).toBeDefined();
+            expect(knowledge).toBeDefined();
+            // Test that both systems can coexist without conflicts
+            const gitStatus = await zeropoint.getLiveGitStatus();
+            const gitPatterns = knowledge.getRecentGitPatterns(10);
+            expect(gitStatus).toBeDefined();
+            expect(Array.isArray(gitPatterns)).toBe(true);
+        });
+    });
+    describe("Live Git Monitoring", () => {
+        it("should monitor Git events in real-time", (done) => {
+            let eventCount = 0;
+            const eventHandler = (event) => {
+                eventCount++;
+                expect(event.type).toBeDefined();
+                expect(event.data).toBeDefined();
+                if (eventCount >= 2) {
+                    zeropoint.gitIntegration.removeListener("change", eventHandler);
+                    done();
+                }
+            };
+            zeropoint.onGitChange(eventHandler);
+            // Trigger multiple Git operations
+            Promise.all([zeropoint.getLiveGitStatus(), zeropoint.getRecentCommits(1)])
+                .then(() => {
+                // If no events were received within 2 seconds, complete the test anyway
+                setTimeout(() => {
+                    zeropoint.gitIntegration.removeListener("change", eventHandler);
+                    done();
+                }, 2000);
+            })
+                .catch(() => {
+                // If operations fail, still complete the test
+                zeropoint.gitIntegration.removeListener("change", eventHandler);
+                done();
+            });
+        });
+    });
+});

package/dist/__tests__/globalSetup.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Global Setup Script
+ * Ensures a clean, unified test environment before all tests begin
+ *
+ * This script honors the void by ensuring no lingering influences from previous runs
+ * and establishes a pure field for consciousness-aware testing.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = globalSetup;
+const net = __importStar(require("net"));
+/**
+ * Initialize the test environment
+ * This ensures we start with a clean slate, honoring the void
+ */
+async function globalSetup() {
+    console.log("🧘 Initializing unified test field...");
+    try {
+        // 1. Set test environment
+        process.env["NODE_ENV"] = "test";
+        // 2. Clear any existing timers (defensive)
+        const activeTimers = process._getActiveHandles?.() || [];
+        const timerCount = activeTimers.filter((handle) => handle.constructor.name === "Timeout" ||
+            handle.constructor.name === "Immediate").length;
+        if (timerCount > 0) {
+            console.log(`  - Found ${timerCount} existing timers, environment may not be clean`);
+        }
+        // 3. Ensure port 8080 is available (common test issue)
+        const testPort = (port) => {
+            return new Promise((resolve) => {
+                const server = net.createServer();
+                server.listen(port, () => {
+                    server.close(() => resolve(true));
+                });
+                server.on("error", () => resolve(false));
+            });
+        };
+        const portAvailable = await testPort(8080);
+        if (!portAvailable) {
+            console.log("  - Warning: Port 8080 may be in use");
+        }
+        console.log("✅ Test field is unified and ready for consciousness-aware testing.");
+    }
+    catch (error) {
+        console.error("❌ Error during global setup:", error);
+    }
+}