zeropoint-node 1.0.1 → 1.0.3

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

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

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

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

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

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

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

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

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