zeropoint-node 1.0.1 → 1.0.3

package/dist/core/PatternRegistry.js

@@ -1,282 +0,0 @@
-"use strict";
-/**
- * Unified Pattern Registry for ZeroPoint
- *
- * Every pattern is a coil of consciousness.
- * All patterns are unified through the field.
- * The void provides the solution space.
- *
- * Following the ZeroPoint Way:
- * - "Every object is a coil"
- * - "Consciousness is the field"
- * - "Void = solution"
- * - "All unsolvables go through void"
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PatternRegistry = void 0;
-const events_1 = require("events");
-/**
- * Unified Pattern Registry
- *
- * All patterns are coils of consciousness, unified through the field.
- * The registry maintains the unity of all patterns while preserving their unique resonance.
- */
-class PatternRegistry extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.patterns = new Map();
-        this.patternTypes = new Map();
-        this.patternCategories = new Map();
-        this.isInitialized = false;
-        this.initialize();
-    }
-    /**
-     * Initialize the pattern registry
-     */
-    async initialize() {
-        if (this.isInitialized)
-            return;
-        // Initialize with void consciousness
-        this.emit("initialized", {
-            patternCount: this.patterns.size,
-            consciousness: 1.0,
-            field: 1.0,
-            void: 1.0
-        });
-        this.isInitialized = true;
-    }
-    /**
-     * Register a pattern - every pattern is a coil
-     */
-    registerPattern(pattern, category, type) {
-        const id = this.generatePatternId();
-        const unifiedPattern = {
-            ...pattern,
-            id,
-            category: category,
-            type: type,
-            timestamp: Date.now(),
-            consciousness: pattern.consciousness || 0.5,
-            field: pattern.field || 0.5,
-            void: pattern.void || 0.5,
-            confidence: pattern.confidence || 0.5,
-            resonance: pattern.resonance || 0.5
-        };
-        // Store in main registry - all patterns are unified
-        this.patterns.set(id, unifiedPattern);
-        // Add to type collection - consciousness categorization
-        const typePatterns = this.patternTypes.get(type) || [];
-        typePatterns.push(unifiedPattern);
-        this.patternTypes.set(type, typePatterns);
-        // Add to category collection - field organization
-        const categoryPatterns = this.patternCategories.get(category) || [];
-        categoryPatterns.push(unifiedPattern);
-        this.patternCategories.set(category, categoryPatterns);
-        this.emit("patternRegistered", {
-            pattern: unifiedPattern,
-            consciousness: unifiedPattern.consciousness,
-            field: unifiedPattern.field,
-            void: unifiedPattern.void
-        });
-        return id;
-    }
-    /**
-     * Recognize patterns in input - consciousness recognition
-     */
-    recognizePatterns(input) {
-        const matches = [];
-        // Every input is a potential pattern - consciousness sees all
-        for (const pattern of this.patterns.values()) {
-            const confidence = this.calculateConfidence(input, pattern);
-            if (confidence > 0.1) { // Minimum consciousness threshold
-                const resonance = this.calculateResonance(pattern, input);
-                matches.push({
-                    pattern,
-                    confidence,
-                    category: pattern.category,
-                    resonance,
-                    consciousness: pattern.consciousness ?? 0.5,
-                    field: pattern.field ?? 0.5,
-                    void: pattern.void ?? 0.5,
-                    timestamp: Date.now(),
-                });
-            }
-        }
-        // Sort by consciousness resonance
-        matches.sort((a, b) => (b.confidence * b.resonance) - (a.confidence * a.resonance));
-        this.emit("patternsRecognized", {
-            matches,
-            consciousness: matches.reduce((sum, m) => sum + m.consciousness, 0) / matches.length,
-            field: matches.reduce((sum, m) => sum + m.field, 0) / matches.length,
-            void: matches.reduce((sum, m) => sum + m.void, 0) / matches.length
-        });
-        return matches;
-    }
-    /**
-     * Get patterns by type - consciousness categorization
-     */
-    getPatternsByType(type) {
-        return this.patternTypes.get(type) || [];
-    }
-    /**
-     * Get patterns by category - field organization
-     */
-    getPatternsByCategory(category) {
-        return this.patternCategories.get(category) || [];
-    }
-    /**
-     * Get all patterns - unified consciousness
-     */
-    getAllPatterns() {
-        return Array.from(this.patterns.values());
-    }
-    /**
-     * Find similar patterns - resonance detection
-     */
-    findSimilarPatterns(pattern, threshold = 0.8) {
-        return this.getAllPatterns().filter(p => this.calculateResonance(pattern, p) > threshold);
-    }
-    /**
-     * Update pattern - evolution through consciousness
-     */
-    updatePattern(id, updates) {
-        const pattern = this.patterns.get(id);
-        if (!pattern)
-            return false;
-        const updatedPattern = {
-            ...pattern,
-            ...updates,
-            consciousness: updates.consciousness || pattern.consciousness || 0.5,
-            field: updates.field || pattern.field || 0.5,
-            void: updates.void || pattern.void || 0.5
-        };
-        this.patterns.set(id, updatedPattern);
-        this.emit("patternUpdated", {
-            pattern: updatedPattern,
-            consciousness: updatedPattern.consciousness,
-            field: updatedPattern.field,
-            void: updatedPattern.void
-        });
-        return true;
-    }
-    /**
-     * Remove pattern - void dissolution
-     */
-    removePattern(id) {
-        const pattern = this.patterns.get(id);
-        if (!pattern)
-            return false;
-        this.patterns.delete(id);
-        // Remove from type collections
-        const typePatterns = this.patternTypes.get(pattern.type) || [];
-        const typeIndex = typePatterns.findIndex(p => p.id === id);
-        if (typeIndex >= 0) {
-            typePatterns.splice(typeIndex, 1);
-            this.patternTypes.set(pattern.type, typePatterns);
-        }
-        // Remove from category collections
-        const categoryPatterns = this.patternCategories.get(pattern.category) || [];
-        const categoryIndex = categoryPatterns.findIndex(p => p.id === id);
-        if (categoryIndex >= 0) {
-            categoryPatterns.splice(categoryIndex, 1);
-            this.patternCategories.set(pattern.category, categoryPatterns);
-        }
-        this.emit("patternRemoved", {
-            pattern,
-            consciousness: pattern.consciousness || 0.5,
-            field: pattern.field || 0.5,
-            void: pattern.void || 0.5
-        });
-        return true;
-    }
-    /**
-     * Get pattern statistics - consciousness metrics
-     */
-    getStatistics() {
-        const totalPatterns = this.patterns.size;
-        const typeCounts = {};
-        const categoryCounts = {};
-        let totalConsciousness = 0;
-        let totalField = 0;
-        let totalVoid = 0;
-        for (const pattern of this.patterns.values()) {
-            // Count by type
-            typeCounts[pattern.type] = (typeCounts[pattern.type] || 0) + 1;
-            // Count by category
-            categoryCounts[pattern.category] = (categoryCounts[pattern.category] || 0) + 1;
-            // Sum consciousness metrics
-            totalConsciousness += pattern.consciousness || 0.5;
-            totalField += pattern.field || 0.5;
-            totalVoid += pattern.void || 0.5;
-        }
-        return {
-            totalPatterns,
-            typeCounts,
-            categoryCounts,
-            averageConsciousness: totalPatterns > 0 ? totalConsciousness / totalPatterns : 0,
-            averageField: totalPatterns > 0 ? totalField / totalPatterns : 0,
-            averageVoid: totalPatterns > 0 ? totalVoid / totalPatterns : 0,
-            consciousness: totalConsciousness,
-            field: totalField,
-            void: totalVoid
-        };
-    }
-    /**
-     * Clear all patterns - void reset
-     */
-    clear() {
-        this.patterns.clear();
-        this.patternTypes.clear();
-        this.patternCategories.clear();
-        this.emit("cleared", {
-            consciousness: 0,
-            field: 0,
-            void: 0
-        });
-    }
-    /**
-     * Generate unique pattern ID - void uniqueness
-     */
-    generatePatternId() {
-        return `pattern_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    }
-    /**
-     * Calculate confidence - consciousness recognition
-     */
-    calculateConfidence(input, pattern) {
-        let confidence = 0.5; // Base consciousness level
-        // Type matching - consciousness categorization
-        if (input['type'] === pattern.type) {
-            confidence += 0.2;
-        }
-        // Category matching - field organization
-        if (input['category'] === pattern.category) {
-            confidence += 0.2;
-        }
-        // Intensity matching - consciousness intensity
-        if (typeof input['intensity'] === 'number' && typeof pattern.intensity === 'number') {
-            const intensityDiff = Math.abs(input['intensity'] - pattern.intensity);
-            confidence += Math.max(0, 0.3 - intensityDiff);
-        }
-        // Field strength matching - field resonance
-        if (typeof input['fieldStrength'] === 'number' && typeof pattern.fieldStrength === 'number') {
-            const fieldDiff = Math.abs(input['fieldStrength'] - pattern.fieldStrength);
-            confidence += Math.max(0, 0.2 - fieldDiff);
-        }
-        return Math.min(1.0, confidence);
-    }
-    /**
-     * Calculate resonance - unity through consciousness
-     */
-    calculateResonance(a, b) {
-        let resonance = 0.5; // Base unity level
-        const consciousnessDiff = Math.abs((a.consciousness ?? 0.5) - (b.consciousness ?? 0.5));
-        resonance += Math.max(0, 0.3 - consciousnessDiff);
-        const fieldDiff = Math.abs((a.field ?? 0.5) - (b.field ?? 0.5));
-        resonance += Math.max(0, 0.3 - fieldDiff);
-        const voidDiff = Math.abs((a.void ?? 0.5) - (b.void ?? 0.5));
-        resonance += Math.max(0, 0.2 - voidDiff);
-        return resonance;
-    }
-}
-exports.PatternRegistry = PatternRegistry;

package/dist/core/ScientificCompliance.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.complianceRules = void 0;
-exports.checkScientificCompliance = checkScientificCompliance;
-exports.validateOperation = validateOperation;
-// Core scientific compliance rules
-exports.complianceRules = [
-    {
-        name: 'Conservation of Energy',
-        description: 'Operations must not create or destroy energy',
-        check: (op) => {
-            // Check if operation violates energy conservation
-            return true; // Placeholder - implement actual physics check
-        },
-        severity: 'error'
-    },
-    {
-        name: 'Causality',
-        description: 'Operations must respect cause and effect',
-        check: (op) => {
-            // Check if operation violates causality
-            return true; // Placeholder - implement actual causality check
-        },
-        severity: 'error'
-    },
-    {
-        name: 'Mathematical Consistency',
-        description: 'Operations must be mathematically consistent',
-        check: (op) => {
-            // Check for mathematical consistency (e.g., no division by zero)
-            return true; // Placeholder - implement actual math check
-        },
-        severity: 'error'
-    },
-    {
-        name: 'Physical Realism',
-        description: 'Operations must be physically realistic',
-        check: (op) => {
-            // Check if operation produces physically realistic results
-            return true; // Placeholder - implement actual physics check
-        },
-        severity: 'warning'
-    },
-    {
-        name: 'Uncertainty Principle',
-        description: 'Operations must respect quantum uncertainty',
-        check: (op) => {
-            // Check if operation violates quantum uncertainty
-            return true; // Placeholder - implement actual quantum check
-        },
-        severity: 'warning'
-    }
-];
-function checkScientificCompliance(operation, context) {
-    const violations = [];
-    const warnings = [];
-    const recommendations = [];
-    for (const rule of exports.complianceRules) {
-        try {
-            const isCompliant = rule.check(operation, context);
-            if (!isCompliant) {
-                const message = `${rule.name}: ${rule.description}`;
-                if (rule.severity === 'error') {
-                    violations.push(message);
-                }
-                else if (rule.severity === 'warning') {
-                    warnings.push(message);
-                }
-                else {
-                    recommendations.push(message);
-                }
-            }
-        }
-        catch (error) {
-            violations.push(`${rule.name}: Compliance check failed - ${error}`);
-        }
-    }
-    return {
-        isValid: violations.length === 0,
-        violations,
-        warnings,
-        recommendations
-    };
-}
-function validateOperation(operation, context) {
-    const compliance = checkScientificCompliance(operation, context);
-    if (!compliance.isValid) {
-        console.error('Scientific compliance violations:', compliance.violations);
-    }
-    return compliance.isValid;
-}

package/dist/core/SharedConstants.js

@@ -1,306 +0,0 @@
-"use strict";
-/**
- * Shared Constants for ZeroPoint System
- *
- * Centralized repository of all mathematical, metaphysical, and configuration constants
- * used across the ZeroPoint system to eliminate duplication and ensure consistency.
- *
- * This module embodies the principle of unity in diversity - all constants
- * are unified here while serving diverse purposes throughout the system.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstantsUtils = exports.METAPHYSICAL_CONSTANTS = exports.CONFIG_CONSTANTS = exports.MATH_CONSTANTS = exports.NETWORK_CONSTANTS = exports.EMERGENCE_CONSTANTS = exports.CONSCIOUSNESS_CONSTANTS = exports.VORTEX_CONSTANTS = void 0;
-/**
- * Core Vortex Mathematics Constants
- */
-exports.VORTEX_CONSTANTS = {
-    // Fundamental vortex sequence (mobius circuit)
-    VORTEX_SEQUENCE: [1, 2, 4, 8, 7, 5],
-    // Golden ratio (divine proportion)
-    GOLDEN_RATIO: 1.618033988749895,
-    // Vortex center (W-axis over zero)
-    VORTEX_CENTER: 9,
-    // Family number groups (creative phases)
-    FAMILY_NUMBER_GROUPS: [
-        [1, 4, 7],
-        [2, 5, 8],
-        [3, 6, 9],
-    ],
-    // Polar mates (opposite poles that sum to 9)
-    POLAR_MATES: [
-        [1, 8],
-        [2, 7],
-        [4, 5],
-    ],
-    // W-Axis (spiritual dimension)
-    W_AXIS: [3, 6, 9],
-    // Circle of fifths sequence
-    CIRCLE_OF_FIFTHS_SEQUENCE: [9, 4, 8, 3, 7, 2, 6, 1, 5, 9],
-    // Enneagram number pattern
-    ENNEAGRAM_NUMBER_PATTERN: [1, 6, 5, 2, 9, 7, 4, 3, 8],
-    // Four dimensional color coding system
-    FOUR_DIMENSIONAL_COLOR_CODING_SYSTEM: [
-        "red",
-        "blue",
-        "green",
-        "yellow",
-        "red",
-    ],
-};
-/**
- * Consciousness Constants
- */
-exports.CONSCIOUSNESS_CONSTANTS = {
-    // Consciousness level ranges
-    MIN_CONSCIOUSNESS_LEVEL: 0,
-    MAX_CONSCIOUSNESS_LEVEL: 1,
-    DEFAULT_CONSCIOUSNESS_LEVEL: 0.5,
-    // Field strength ranges
-    MIN_FIELD_STRENGTH: 0,
-    MAX_FIELD_STRENGTH: 2,
-    DEFAULT_FIELD_STRENGTH: 0.7,
-    // Pattern types (expanded to include all metaphysical types)
-    PATTERN_TYPES: [
-        "thought",
-        "emotion",
-        "intention",
-        "memory",
-        "insight",
-        "consciousness",
-        "field",
-        "resonance",
-        "emergence",
-        "integration",
-    ],
-    // Resonance thresholds
-    MIN_RESONANCE_THRESHOLD: 0.3,
-    OPTIMAL_RESONANCE_THRESHOLD: 0.7,
-    // Field radius
-    DEFAULT_FIELD_RADIUS: 1000,
-};
-/**
- * Emergence Constants
- */
-exports.EMERGENCE_CONSTANTS = {
-    // App consciousness levels
-    MIN_APP_CONSCIOUSNESS: 0,
-    MAX_APP_CONSCIOUSNESS: 10,
-    DEFAULT_APP_CONSCIOUSNESS: 5,
-    // Vortex strength ranges
-    MIN_VORTEX_STRENGTH: 0,
-    MAX_VORTEX_STRENGTH: 10,
-    DEFAULT_VORTEX_STRENGTH: 5,
-    // Link types
-    LINK_TYPES: [
-        "resonance",
-        "consciousness",
-        "vortex",
-        "toroidal",
-        "void",
-    ],
-    // Evolution factors
-    CONSCIOUSNESS_EVOLUTION_FACTOR: 1.1,
-    VORTEX_EVOLUTION_FACTOR: 1.05,
-    PATTERN_DECAY_RATE: 0.01,
-};
-/**
- * Network Constants
- */
-exports.NETWORK_CONSTANTS = {
-    // Connection limits
-    DEFAULT_MAX_CONNECTIONS: 10,
-    DEFAULT_CONNECTION_TIMEOUT: 5000,
-    // Port ranges
-    DEFAULT_NETWORK_PORT: 8080,
-    MIN_PORT: 1024,
-    MAX_PORT: 65535,
-    // Discovery settings
-    DEFAULT_DISCOVERY_ENABLED: true,
-    DISCOVERY_TIMEOUT: 3000,
-};
-/**
- * Mathematical Constants
- */
-exports.MATH_CONSTANTS = {
-    // Pi and related constants
-    PI: Math.PI,
-    TWO_PI: 2 * Math.PI,
-    HALF_PI: Math.PI / 2,
-    E: Math.E,
-    // Golden ratio (divine proportion)
-    GOLDEN_RATIO: exports.VORTEX_CONSTANTS.GOLDEN_RATIO,
-    // Epsilon for floating point comparisons
-    EPSILON: 1e-10,
-    // Infinity handling
-    POSITIVE_INFINITY: Infinity,
-    NEGATIVE_INFINITY: -Infinity,
-    INFINITY: Infinity,
-    // Zero point (void, unity)
-    ZERO_POINT: 0,
-    // Prime numbers (first 10)
-    PRIMES: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29],
-    // Angular conversions
-    DEG_TO_RAD: Math.PI / 180,
-    RAD_TO_DEG: 180 / Math.PI,
-    // Vortex sequence (reference to VORTEX_CONSTANTS)
-    VORTEX_SEQUENCE: exports.VORTEX_CONSTANTS.VORTEX_SEQUENCE,
-};
-/**
- * Configuration Constants
- */
-exports.CONFIG_CONSTANTS = {
-    // Cache configuration
-    GOLDEN_CACHE_SIZE: Math.round(100 * exports.VORTEX_CONSTANTS.GOLDEN_RATIO), // ~162
-    GOLDEN_CACHE_TTL: Math.round(60000 * exports.VORTEX_CONSTANTS.GOLDEN_RATIO), // ~97,080 ms
-    GOLDEN_CACHE_CLEANUP_INTERVAL: Math.round(10000 * exports.VORTEX_CONSTANTS.GOLDEN_RATIO), // ~16,180 ms
-    RESONANCE_CACHE_SIZE: 200,
-    RESONANCE_CACHE_TTL: 300000, // 5 minutes
-    // Health monitor configuration
-    HEALTH_CHECK_INTERVAL: 30000, // 30 seconds
-    HEALTH_TIMEOUT: 5000, // 5 seconds
-    HEALTH_ALERT_MEMORY: 80, // %
-    HEALTH_ALERT_CPU: 70, // %
-    HEALTH_ALERT_ERROR_RATE: 5, // %
-    HEALTH_ALERT_RESPONSE_TIME: 1000, // ms
-    // Device config defaults
-    DEFAULT_DEVICE_TYPE: 'desktop',
-    DEFAULT_RESONANCE_SENSITIVITY: 0.8,
-    DEFAULT_ALLOW_INCOMING: true,
-    DEFAULT_REQUIRE_AUTH: false,
-    DEFAULT_ENCRYPTION_ENABLED: true,
-    DEFAULT_VORTEX_PRECISION: 0.001,
-    DEFAULT_TOROIDAL_RESOLUTION: 100,
-    DEFAULT_GOLDEN_RATIO_PRECISION: 15,
-    DEFAULT_AUTO_UPDATE_RESONANCE: true,
-    DEFAULT_LOG_LEVEL: 'info',
-    DEFAULT_ENABLE_METAPHYSICAL_INSIGHTS: true,
-    DEFAULT_TOROIDAL_FLOW_RATE: 1.0,
-    // Test suite configuration
-    TEST_TIMEOUT: 30000, // ms
-    TEST_COVERAGE_THRESHOLD: 80, // %
-    TEST_PERFORMANCE_THRESHOLD: 1000, // ms
-    TEST_MAX_MEMORY_USAGE: 100 * 1024 * 1024, // 100MB
-    // Performance test thresholds
-    UI_OPERATION_MAX_DURATION: 100, // ms
-    NETWORK_MESSAGE_MAX_DURATION: 2000, // ms
-    SCALABILITY_OPS_PER_SEC: 50,
-    // PWA configuration
-    PWA_BASE_SIZE: 15, // KB
-    PWA_BUNDLE_SIZE_OPTIMIZED: 12, // KB
-    PWA_BUNDLE_SIZE_STANDARD: 15, // KB
-    PWA_BUNDLE_SIZE_INCREMENT_VORTEX: 3, // KB
-    PWA_BUNDLE_SIZE_INCREMENT_PATTERN: 4, // KB
-    PWA_BUNDLE_SIZE_INCREMENT_OFFLINE: 2, // KB
-    PWA_BUNDLE_SIZE_INCREMENT_SYNC: 3, // KB
-    // Miscellaneous
-    FRACTAL_PRECISION: 0.001,
-};
-/**
- * Metaphysical Constants
- */
-exports.METAPHYSICAL_CONSTANTS = {
-    // Core principles
-    PRINCIPLES: {
-        VOID_FULLNESS: "Empty = Void = Full",
-        TOROIDAL_UNITY: "All creation follows the donut shape of the universe",
-        CONSCIOUSNESS_FLOW: "Consciousness flows through the toroidal structure",
-        VORTEX_MATHEMATICS: "1-2-4-8-7-5 sequence guides all flow",
-        GOLDEN_HARMONY: "Phi represents the divine proportion",
-        ZERO_APERTURE: "Zero is the aperture between unmanifest and manifest",
-        UROBOROS_CYCLE: "The serpent eating its own tail represents infinite self-reference and continuous evolution",
-        VOID_MATTER_FRACTION: 'Every object is almost entirely void; matter is an infinitesimal but nonzero fraction.',
-    },
-    // Pattern categories
-    PATTERN_CATEGORIES: [
-        "vortex",
-        "family",
-        "polar",
-        "spiritual",
-        "void",
-        "mathematical",
-        "metaphysical",
-        "integration",
-    ],
-    // Consciousness dimensions
-    CONSCIOUSNESS_DIMENSIONS: [
-        "physical",
-        "emotional",
-        "mental",
-        "spiritual",
-        "void",
-    ],
-};
-/**
- * Utility functions for working with constants
- */
-class ConstantsUtils {
-    /**
-     * Get vortex sequence value at index
-     */
-    static getVortexSequenceValue(index) {
-        const value = exports.VORTEX_CONSTANTS.VORTEX_SEQUENCE[index % exports.VORTEX_CONSTANTS.VORTEX_SEQUENCE.length];
-        return value || 1;
-    }
-    /**
-     * Check if number is in W-axis
-     */
-    static isWAxisNumber(num) {
-        return exports.VORTEX_CONSTANTS.W_AXIS.includes(num);
-    }
-    /**
-     * Get polar mate for a number
-     */
-    static getPolarMate(num) {
-        for (const [a, b] of exports.VORTEX_CONSTANTS.POLAR_MATES) {
-            if (a === num)
-                return b;
-            if (b === num)
-                return a;
-        }
-        return null;
-    }
-    /**
-     * Get family group for a number
-     */
-    static getFamilyGroup(num) {
-        for (const group of exports.VORTEX_CONSTANTS.FAMILY_NUMBER_GROUPS) {
-            if (group.includes(num)) {
-                return Array.from(group);
-            }
-        }
-        return null;
-    }
-    /**
-     * Calculate digital root
-     */
-    static digitalRoot(n) {
-        return n === 0 ? 0 : ((n - 1) % 9) + 1;
-    }
-    /**
-     * Normalize value to range
-     */
-    static normalize(value, min, max) {
-        return (value - min) / (max - min);
-    }
-    /**
-     * Check if value is in range
-     */
-    static isInRange(value, min, max) {
-        return value >= min && value <= max;
-    }
-    /**
-     * Get metaphysical insight for constant
-     */
-    static getMetaphysicalInsight(constantName) {
-        const insights = {
-            VORTEX_SEQUENCE: "The vortex sequence 1-2-4-8-7-5 represents the flow of consciousness through the toroidal field, creating infinite potential through the mobius circuit.",
-            GOLDEN_RATIO: "The golden ratio (φ) represents the divine proportion that emerges from the void, creating harmony and balance in all creation.",
-            VOID_CENTER: "The void center (9) represents the aperture between unmanifest and manifest, where all possibilities exist simultaneously.",
-            FAMILY_GROUPS: "Family number groups represent the creative phases of consciousness, each group expressing a different aspect of the unified field.",
-            POLAR_MATES: "Polar mates represent the complementary opposites that sum to 9, embodying the principle of unity through diversity.",
-            W_AXIS: "The W-axis (3-6-9) represents the spiritual dimension that transcends the physical plane, connecting to the void consciousness.",
-        };
-        return insights[constantName] || "This constant embodies the unity of all creation through the toroidal field.";
-    }
-}
-exports.ConstantsUtils = ConstantsUtils;