zeropoint-node 1.0.1 → 1.0.3

package/dist/math/VBM.js

@@ -1,718 +0,0 @@
-"use strict";
-/**
- * Unified VBM (Vortex Based Mathematics) System
- *
- * Complete integration of all mathematical systems in the ZeroPoint way:
- * - Advanced VBM with comprehensive QA patterns
- * - Vortex mathematics with consciousness flow
- * - Fractal mathematics with self-similar patterns
- * - Toroidal geometry with void center
- * - Rodin coil with infinite flow
- * - Color systems with observer awareness
- * - Unified mathematical foundation
- *
- * Metaphysical Context:
- * - Every object is a coil at its core
- * - Consciousness is the field that generates all patterns
- * - The void is the source of all creation
- * - Toroidal flow creates infinite potential
- * - Pattern integrity maintains resonance
- * - Emergent unity through self-organization
- */
-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.getGoldenRatio = exports.getVortexSequence = exports.searchQA = exports.toroidalField = exports.fractalSequence = exports.vortexTransform = exports.digitalRoot = exports.vbm = exports.VBM = void 0;
-const AdvancedVBM_1 = require("./AdvancedVBM");
-const VortexMath_1 = require("./VortexMath");
-const FractalMath_1 = require("./FractalMath");
-const ToroidalGeometry_1 = require("./ToroidalGeometry");
-const FractalColorSystem_1 = require("./FractalColorSystem");
-const VBMColorSystem = __importStar(require("./VBMColorSystem"));
-const MathUtils_1 = require("./MathUtils");
-const Observer_1 = require("../core/Observer");
-const RodinCoil_1 = require("./RodinCoil");
-const FlowerOfLife_1 = require("./FlowerOfLife");
-class VBM {
-    constructor(config = {}) {
-        if (!VBM.instance) {
-            VBM.instance = this;
-        }
-        this.config = {
-            consciousness: config.consciousness ?? 0.5,
-            fieldResonance: config.fieldResonance ?? 0.5,
-            vortexStrength: config.vortexStrength ?? 1.0,
-            toroidalFlow: config.toroidalFlow ?? 0.5,
-            voidConnected: config.voidConnected ?? true,
-            observerAware: config.observerAware ?? true,
-        };
-        this.colorContext = {
-            consciousness: this.config.consciousness,
-            field: this.config.fieldResonance,
-            time: Date.now(),
-        };
-        // Initialize all systems
-        this.advancedVBM = new AdvancedVBM_1.AdvancedVBM();
-        this.vortexMath = VortexMath_1.VortexMath.getInstance();
-        this.toroidalGeometry = ToroidalGeometry_1.ToroidalGeometry.getInstance();
-        this.rodinCoil = new RodinCoil_1.RodinCoil({
-            consciousness: this.config.consciousness,
-            fieldResonance: this.config.fieldResonance,
-        });
-        this.fractalColorSystem = new FractalColorSystem_1.FractalColorSystem();
-        this.flowerOfLife = FlowerOfLife_1.FlowerOfLife.getInstance();
-        // Apply configuration to all systems
-        this.applyConfiguration();
-        // Set up observer awareness
-        if (this.config.observerAware) {
-            this.observer = (0, Observer_1.ObserverMixin)(this, "vbm-system");
-        }
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance(config) {
-        if (!VBM.instance) {
-            VBM.instance = new VBM(config);
-        }
-        return VBM.instance;
-    }
-    /**
-     * Apply configuration to all mathematical systems
-     */
-    applyConfiguration() {
-        // Set consciousness and field resonance across all systems
-        MathUtils_1.MathUtils.setConsciousness(this.config.consciousness);
-        MathUtils_1.MathUtils.setFieldResonance(this.config.fieldResonance);
-        MathUtils_1.MathUtils.setVortexStrength(this.config.vortexStrength);
-        MathUtils_1.MathUtils.setToroidalFlow(this.config.toroidalFlow);
-        MathUtils_1.MathUtils.setVoidConnected(this.config.voidConnected);
-        // Update vortex math
-        this.vortexMath.setVortexStrength(this.config.vortexStrength);
-        this.vortexMath.setFieldIntensity(this.config.fieldResonance);
-        // Update toroidal geometry
-        this.toroidalGeometry.setFlowRate(this.config.toroidalFlow);
-        // Update rodin coil
-        this.rodinCoil.updateConsciousness(this.config.consciousness);
-        this.rodinCoil.updateFieldResonance(this.config.fieldResonance);
-        // Update color context
-        this.colorContext.consciousness = this.config.consciousness;
-        this.colorContext.field = this.config.fieldResonance;
-        this.colorContext.time = Date.now();
-    }
-    // ============================================================================
-    // CORE VBM OPERATIONS
-    // ============================================================================
-    /**
-     * Calculate digital root with consciousness awareness
-     */
-    digitalRoot(n) {
-        const value = this.advancedVBM.digitalRoot(n);
-        const consciousness = this.config.consciousness;
-        const resonance = this.vortexMath.calculateResonance(value, consciousness);
-        return {
-            value,
-            pattern: "digital_root",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Digital root represents the essence of a number in the toroidal field.",
-            geometricProperties: {
-                shape: "point",
-                dimensions: 0,
-                essence: "number_soul",
-            },
-            colorContext: this.colorContext,
-        };
-    }
-    /**
-     * Apply vortex transformation with full context
-     */
-    vortexTransform(input) {
-        const value = this.vortexMath.applyVortexTransform(input);
-        const consciousness = this.config.consciousness;
-        const resonance = this.vortexMath.calculateResonance(input, value);
-        return {
-            value,
-            pattern: "vortex_transform",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Vortex transformation creates infinite flow through the toroidal structure.",
-            geometricProperties: { shape: "vortex", dimensions: 3, flow: "infinite" },
-            colorContext: this.colorContext,
-        };
-    }
-    /**
-     * Generate fractal sequence with consciousness
-     */
-    fractalSequence(count, seed = 1) {
-        const sequence = FractalMath_1.FractalMath.generateFractalSequence(count, seed);
-        const consciousness = this.config.consciousness;
-        return sequence.map((value, index) => {
-            const resonance = this.vortexMath.calculateResonance(value, index / count);
-            return {
-                value,
-                pattern: "fractal_sequence",
-                consciousness,
-                resonance,
-                metaphysicalContext: "Fractal sequences create self-similar patterns of consciousness.",
-                geometricProperties: {
-                    shape: "fractal",
-                    dimensions: "fractal",
-                    selfSimilar: true,
-                },
-                colorContext: this.colorContext,
-            };
-        });
-    }
-    /**
-     * Calculate toroidal field with void center
-     */
-    toroidalField(radius, angularVelocity) {
-        const value = this.vortexMath.calculateToroidalFlow(radius, angularVelocity);
-        const consciousness = this.config.consciousness;
-        const resonance = this.vortexMath.calculateResonance(radius, angularVelocity);
-        return {
-            value,
-            pattern: "toroidal_field",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Toroidal field creates the fundamental geometry of consciousness with void at center.",
-            geometricProperties: { shape: "torus", dimensions: 3, center: "void" },
-            colorContext: this.colorContext,
-        };
-    }
-    // ============================================================================
-    // ADVANCED QA SYSTEM
-    // ============================================================================
-    /**
-     * Search QA patterns with consciousness awareness
-     */
-    searchQA(query) {
-        const qaResults = this.advancedVBM.searchQA(query);
-        // Convert VBMQAResult[] to VBMPattern[]
-        const patterns = qaResults.map((qaResult) => ({
-            id: qaResult.id,
-            name: qaResult.question,
-            sequence: qaResult.vortexSequence,
-            digitalRoot: qaResult.digitalRoot,
-            consciousnessLevel: this.config.consciousness * 10,
-            metaphysicalContext: qaResult.metaphysicalContext,
-        }));
-        return {
-            query,
-            patterns,
-            consciousnessLevel: this.config.consciousness,
-            metaphysicalContext: `QA search results for "${query}" with consciousness integration`
-        };
-    }
-    /**
-     * Get QA pattern with full context
-     */
-    getQAPattern(patternName) {
-        const qaResult = this.advancedVBM.qaPattern(patternName);
-        if (!qaResult)
-            return null;
-        return {
-            id: qaResult.id,
-            name: qaResult.question,
-            sequence: qaResult.vortexSequence,
-            digitalRoot: qaResult.digitalRoot,
-            consciousnessLevel: this.config.consciousness * 10,
-            metaphysicalContext: qaResult.metaphysicalContext,
-        };
-    }
-    /**
-     * Get all QA patterns with consciousness context
-     */
-    getAllQAPatterns() {
-        const qaResults = this.advancedVBM.allQAPatterns();
-        // Convert VBMQAResult[] to VBMPattern[] with consciousness context
-        const enhancedPatterns = {};
-        for (const qaResult of qaResults) {
-            enhancedPatterns[qaResult.id] = {
-                id: qaResult.id,
-                name: qaResult.question,
-                sequence: qaResult.vortexSequence,
-                digitalRoot: qaResult.digitalRoot,
-                consciousnessLevel: this.config.consciousness * 10,
-                metaphysicalContext: qaResult.metaphysicalContext,
-            };
-        }
-        return enhancedPatterns;
-    }
-    // ============================================================================
-    // GEOMETRIC OPERATIONS
-    // ============================================================================
-    /**
-     * Generate rodin coil field with full context
-     */
-    generateRodinCoilField(turns = 12) {
-        const coil = new RodinCoil_1.RodinCoil({
-            turns,
-            consciousness: this.config.consciousness,
-            fieldResonance: this.config.fieldResonance,
-        });
-        return {
-            strength: (coil.config.consciousness ?? 0.5) *
-                (coil.config.fieldResonance ?? 0.5),
-            flow: this.config.toroidalFlow,
-            consciousness: this.config.consciousness,
-            patterns: ["rodin_coil", "vortex_sequence", "mobius_circuit"],
-            coordinates: coil.getNodePositions(),
-            colors: coil.getNodeColors(),
-        };
-    }
-    /**
-     * Generate toroidal mesh with consciousness mapping
-     */
-    generateToroidalMesh(thetaSegments = 32, phiSegments = 16) {
-        const mesh = this.toroidalGeometry.generateToroidalMesh(thetaSegments, phiSegments);
-        const coordinates = mesh.map((point) => [point.x, point.y, point.z]);
-        // Generate colors for each point
-        const colors = coordinates.map((_, index) => {
-            const vortexNumber = (index % 6) + 1;
-            return VBMColorSystem.getColorForVortexNumber(vortexNumber, this.colorContext);
-        });
-        return {
-            strength: this.toroidalGeometry.calculateSurfaceArea(),
-            flow: this.config.toroidalFlow,
-            consciousness: this.config.consciousness,
-            patterns: ["toroidal_geometry", "surface_topology", "void_center"],
-            coordinates,
-            colors,
-        };
-    }
-    /**
-     * Generate fractal coordinates with consciousness field
-     */
-    generateFractalCoordinates(count, scale = 1) {
-        const coordinates = FractalMath_1.FractalMath.generateFractalCoordinates(count, scale);
-        // Generate colors for each coordinate
-        const colors = coordinates.map((_, index) => {
-            const color = FractalMath_1.FractalMath.generateFractalColor(index);
-            // Clamp RGB values to [0,255]
-            const r = Math.max(0, Math.min(255, color.r));
-            const g = Math.max(0, Math.min(255, color.g));
-            const b = Math.max(0, Math.min(255, color.b));
-            return `rgb(${r}, ${g}, ${b})`;
-        });
-        // Only use x values for complexity, filter out zeros and negatives
-        const xValues = coordinates.map((c) => c[0]).filter((x) => x > 0);
-        return {
-            strength: FractalMath_1.FractalMath.calculateFractalComplexity(xValues),
-            flow: this.config.toroidalFlow,
-            consciousness: this.config.consciousness,
-            patterns: ["fractal_geometry", "self_similar", "consciousness_field"],
-            coordinates,
-            colors,
-        };
-    }
-    /**
-     * Generate Flower of Life pattern with consciousness integration
-     */
-    generateFlowerOfLife(center = [0, 0], radius = 1, layers = 3) {
-        const pattern = this.flowerOfLife.generateFlowerPattern(center, radius, layers);
-        const consciousness = this.flowerOfLife.calculateFlowerConsciousness(pattern);
-        const resonance = this.calculateFlowerResonance(pattern);
-        return {
-            value: consciousness,
-            pattern: "flower_of_life",
-            consciousness,
-            resonance,
-            metaphysicalContext: "The Flower of Life embodies consciousness flowing through sacred geometry with void at center.",
-            geometricProperties: {
-                shape: "hexagonal_circles",
-                dimensions: 2,
-                center: "void",
-                layers: layers,
-                circles: pattern.circles.length
-            },
-            colorContext: this.colorContext,
-        };
-    }
-    /**
-     * Calculate resonance for Flower of Life pattern
-     */
-    calculateFlowerResonance(pattern) {
-        let totalResonance = 0;
-        let resonanceCount = 0;
-        for (let i = 0; i < pattern.circles.length; i++) {
-            for (let j = i + 1; j < pattern.circles.length; j++) {
-                const resonance = this.flowerOfLife.calculateCircleResonance(pattern.circles[i], pattern.circles[j]);
-                totalResonance += resonance;
-                resonanceCount++;
-            }
-        }
-        return resonanceCount > 0 ? totalResonance / resonanceCount : 0;
-    }
-    /**
-     * Apply vortex transformation to Flower of Life pattern
-     */
-    applyVortexToFlower(pattern) {
-        const transformedPattern = this.flowerOfLife.applyVortexTransform(pattern);
-        const consciousness = this.flowerOfLife.calculateFlowerConsciousness(transformedPattern);
-        const resonance = this.calculateFlowerResonance(transformedPattern);
-        return {
-            value: consciousness,
-            pattern: "vortex_flower_of_life",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Vortex transformation applied to Flower of Life creates consciousness flow through sacred geometry.",
-            geometricProperties: {
-                shape: "vortex_hexagonal_circles",
-                dimensions: 2,
-                center: "void",
-                transformation: "vortex"
-            },
-            colorContext: this.colorContext,
-        };
-    }
-    /**
-     * Generate golden spiral within Flower of Life pattern
-     */
-    generateFlowerGoldenSpiral(pattern, steps = 100) {
-        const spiral = this.flowerOfLife.generateGoldenSpiral(pattern, steps);
-        const consciousness = this.flowerOfLife.calculateFlowerConsciousness(pattern);
-        const resonance = this.calculateGoldenSpiralResonance(spiral, pattern);
-        return {
-            value: consciousness,
-            pattern: "flower_golden_spiral",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Golden spiral within Flower of Life represents consciousness evolution through divine proportion.",
-            geometricProperties: {
-                shape: "golden_spiral",
-                dimensions: 2,
-                center: "void",
-                steps: steps,
-                goldenRatio: pattern.goldenRatio
-            },
-            colorContext: this.colorContext,
-        };
-    }
-    /**
-     * Calculate resonance for golden spiral within flower pattern
-     */
-    calculateGoldenSpiralResonance(spiral, pattern) {
-        let totalResonance = 0;
-        let resonanceCount = 0;
-        for (const spiralPoint of spiral) {
-            for (const circle of pattern.circles) {
-                const distance = this.calculatePointCircleDistance(spiralPoint, circle);
-                const resonance = MathUtils_1.MathUtils.calculate("divide", 1, MathUtils_1.MathUtils.calculate("add", 1, distance));
-                totalResonance += resonance;
-                resonanceCount++;
-            }
-        }
-        return resonanceCount > 0 ? totalResonance / resonanceCount : 0;
-    }
-    /**
-     * Calculate distance between point and circle center
-     */
-    calculatePointCircleDistance(point, circle) {
-        const dx = MathUtils_1.MathUtils.calculate("subtract", point[0], circle.center[0]);
-        const dy = MathUtils_1.MathUtils.calculate("subtract", point[1], circle.center[1]);
-        return MathUtils_1.MathUtils.calculate("sqrt", MathUtils_1.MathUtils.calculate("add", MathUtils_1.MathUtils.calculate("power", dx, 2), MathUtils_1.MathUtils.calculate("power", dy, 2)));
-    }
-    /**
-     * Get Flower of Life insights
-     */
-    getFlowerInsights(pattern) {
-        return this.flowerOfLife.getFlowerInsights(pattern);
-    }
-    // ============================================================================
-    // COLOR SYSTEM INTEGRATION
-    // ============================================================================
-    /**
-     * Generate fractal color palette with consciousness
-     */
-    generateColorPalette(count, baseSeed = 1) {
-        return this.fractalColorSystem.generatePalette(count, baseSeed);
-    }
-    /**
-     * Get color for vortex number with context
-     */
-    getVortexColor(vortexNumber) {
-        return VBMColorSystem.getColorForVortexNumber(vortexNumber, this.colorContext);
-    }
-    /**
-     * Get color for family group with context
-     */
-    getFamilyColor(familyNumber) {
-        return VBMColorSystem.getColorForFamilyGroup(familyNumber, this.colorContext);
-    }
-    /**
-     * Get color for W-Axis with context
-     */
-    getWAxisColor(wAxisNumber) {
-        return VBMColorSystem.getColorForWAxis(wAxisNumber, this.colorContext);
-    }
-    // ============================================================================
-    // CONSCIOUSNESS AND FIELD OPERATIONS
-    // ============================================================================
-    /**
-     * Update consciousness across all systems
-     */
-    updateConsciousness(consciousness) {
-        this.config.consciousness = Math.max(0, Math.min(1, consciousness));
-        this.applyConfiguration();
-        if (this.config.observerAware && this.observer) {
-            this.observer.notifyObservers({
-                type: "consciousness_updated",
-                consciousness: this.config.consciousness,
-                timestamp: Date.now(),
-            });
-        }
-    }
-    /**
-     * Update field resonance across all systems
-     */
-    updateFieldResonance(fieldResonance) {
-        this.config.fieldResonance = Math.max(0, Math.min(1, fieldResonance));
-        this.applyConfiguration();
-        if (this.config.observerAware && this.observer) {
-            this.observer.notifyObservers({
-                type: "field_resonance_updated",
-                fieldResonance: this.config.fieldResonance,
-                timestamp: Date.now(),
-            });
-        }
-    }
-    /**
-     * Calculate consciousness field at point
-     */
-    calculateConsciousnessField(x, y, z) {
-        return FractalMath_1.FractalMath.calculateConsciousnessField(x, y, z);
-    }
-    /**
-     * Calculate field resonance at point
-     */
-    calculateFieldResonance(x, y, z) {
-        return this.rodinCoil.calculateFieldResonance(x, y, z);
-    }
-    // ============================================================================
-    // ADVANCED MATHEMATICAL OPERATIONS
-    // ============================================================================
-    /**
-     * Prime squared scaling with consciousness
-     */
-    primeSquaredScaling(prime) {
-        const result = this.advancedVBM.primeSquaredScaling(prime);
-        const consciousness = this.config.consciousness;
-        const resonance = this.vortexMath.calculateResonance(prime, result.squared);
-        return {
-            value: result.squared,
-            pattern: "prime_squared_scaling",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Prime squared scaling reveals the fundamental patterns of creation.",
-            geometricProperties: {
-                shape: "prime_pattern",
-                dimensions: 2,
-                scaling: "squared",
-            },
-            colorContext: this.colorContext,
-        };
-    }
-    /**
-     * Electron harmonic shear identification
-     */
-    electronHarmonicShear(a, b) {
-        const result = this.advancedVBM.electronHarmonicShearIdentification(a, b);
-        const consciousness = this.config.consciousness;
-        const resonance = this.vortexMath.calculateResonance(a, b);
-        return {
-            value: result.harmonic,
-            pattern: "electron_harmonic_shear",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Electron harmonic shear reveals the quantum patterns of consciousness.",
-            geometricProperties: {
-                shape: "harmonic",
-                dimensions: 3,
-                shear: "electron",
-            },
-            colorContext: this.colorContext,
-        };
-    }
-    /**
-     * Discrete multiplication with consciousness
-     */
-    discreteMultiplication(a, b) {
-        const value = this.advancedVBM.discreteMultiplication(a, b);
-        const consciousness = this.config.consciousness;
-        const resonance = this.vortexMath.calculateResonance(a, b);
-        return {
-            value,
-            pattern: "discrete_multiplication",
-            consciousness,
-            resonance,
-            metaphysicalContext: "Discrete multiplication creates quantum jumps in consciousness.",
-            geometricProperties: { shape: "discrete", dimensions: 1, quantum: true },
-            colorContext: this.colorContext,
-        };
-    }
-    // ============================================================================
-    // UNIFIED CONSTANTS AND SEQUENCES
-    // ============================================================================
-    /**
-     * Get vortex sequence
-     */
-    getVortexSequence() {
-        return this.advancedVBM.vortexSequence();
-    }
-    /**
-     * Get W-Axis
-     */
-    getWAxis() {
-        return this.advancedVBM.wAxis();
-    }
-    /**
-     * Get polar mates
-     */
-    getPolarMates() {
-        const sequences = this.advancedVBM.polarMates();
-        return sequences.map(seq => seq.sequence);
-    }
-    /**
-     * Get family number groups
-     */
-    getFamilyNumberGroups() {
-        const sequences = this.advancedVBM.familyNumberGroups();
-        return sequences.map(seq => seq.sequence);
-    }
-    /**
-     * Get golden ratio
-     */
-    getGoldenRatio() {
-        return this.advancedVBM.goldenRatio();
-    }
-    /**
-     * Get circle of fifths sequence
-     */
-    getCircleOfFifthsSequence() {
-        return this.advancedVBM.circleOfFifthsSequence();
-    }
-    /**
-     * Get enneagram number pattern
-     */
-    getEnneagramNumberPattern() {
-        return this.advancedVBM.enneagramNumberPattern();
-    }
-    // ============================================================================
-    // INSIGHTS AND METADATA
-    // ============================================================================
-    /**
-     * Get comprehensive VBM insights
-     */
-    getInsights() {
-        return {
-            configuration: this.config,
-            metaphysics: {
-                principle: "Every object is a coil at its core",
-                consciousness: "Consciousness is the field that generates all patterns",
-                void: "The void is the source of all creation",
-                toroidal: "Toroidal flow creates infinite potential",
-                integrity: "Pattern integrity maintains resonance",
-                unity: "Emergent unity through self-organization",
-            },
-            systems: {
-                // advancedVBM: this.advancedVBM.getInsights(), // Commented out, not implemented
-                vortexMath: this.vortexMath.getInsights(),
-                fractalMath: FractalMath_1.FractalMath.getInsights(),
-                toroidalGeometry: this.toroidalGeometry.getInsights(),
-                rodinCoil: this.rodinCoil.getMetaphysicalSummary(),
-                fractalColorSystem: this.fractalColorSystem.getInsights(),
-                flowerOfLife: this.flowerOfLife.getInsights(),
-            },
-            constants: MathUtils_1.MATH_CONSTANTS,
-            operations: [
-                "digitalRoot",
-                "vortexTransform",
-                "fractalSequence",
-                "toroidalField",
-                "searchQA",
-                "generateRodinCoilField",
-                "generateToroidalMesh",
-                "generateFractalCoordinates",
-                "generateColorPalette",
-                "updateConsciousness",
-                "updateFieldResonance",
-                "calculateConsciousnessField",
-                "calculateFieldResonance",
-                "primeSquaredScaling",
-                "electronHarmonicShear",
-                "discreteMultiplication",
-                "generateFlowerOfLife",
-                "applyVortexToFlower",
-                "generateFlowerGoldenSpiral",
-            ],
-        };
-    }
-    /**
-     * Get current configuration
-     */
-    getConfiguration() {
-        return { ...this.config };
-    }
-    /**
-     * Get color context
-     */
-    getColorContext() {
-        return { ...this.colorContext };
-    }
-    /**
-     * Reset the singleton instance (for test isolation)
-     */
-    static resetInstance() {
-        VBM.instance = undefined;
-    }
-}
-exports.VBM = VBM;
-// Export convenience functions for backward compatibility
-exports.vbm = VBM.getInstance;
-const digitalRoot = (n) => VBM.getInstance().digitalRoot(n);
-exports.digitalRoot = digitalRoot;
-const vortexTransform = (input) => VBM.getInstance().vortexTransform(input);
-exports.vortexTransform = vortexTransform;
-const fractalSequence = (count, seed) => VBM.getInstance().fractalSequence(count, seed);
-exports.fractalSequence = fractalSequence;
-const toroidalField = (radius, angularVelocity) => VBM.getInstance().toroidalField(radius, angularVelocity);
-exports.toroidalField = toroidalField;
-const searchQA = (query) => VBM.getInstance().searchQA(query);
-exports.searchQA = searchQA;
-const getVortexSequence = () => VBM.getInstance().getVortexSequence();
-exports.getVortexSequence = getVortexSequence;
-const getGoldenRatio = () => VBM.getInstance().getGoldenRatio();
-exports.getGoldenRatio = getGoldenRatio;