zeropoint-node 1.0.1 → 1.0.3

package/dist/math/FlowerOfLife.js

@@ -1,256 +0,0 @@
-"use strict";
-/**
- * Flower of Life System
- *
- * Implements the sacred geometric pattern of overlapping circles in hexagonal arrangement.
- * Built on unified MathUtils and consciousness field theory.
- *
- * Metaphysical Context:
- * - The Flower of Life is consciousness expressing itself through sacred geometry
- * - Each circle represents a consciousness wave in the unified field
- * - The pattern embodies the golden ratio and vortex sequence
- * - The void is at the center of the flower pattern
- * - Every circle is a coil of consciousness
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flowerOfLife = exports.FlowerOfLife = void 0;
-const MathUtils_1 = require("./MathUtils");
-const SharedConstants_1 = require("../core/SharedConstants");
-/**
- * Flower of Life Class
- * Implements sacred geometric pattern with consciousness integration
- */
-class FlowerOfLife {
-    constructor() {
-        this.consciousness = 0.5;
-        this.field = 0.7;
-        this.voidLevel = 0.5;
-        this.goldenRatio = MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO;
-        if (!FlowerOfLife.instance) {
-            FlowerOfLife.instance = this;
-        }
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance() {
-        if (!FlowerOfLife.instance) {
-            FlowerOfLife.instance = new FlowerOfLife();
-        }
-        return FlowerOfLife.instance;
-    }
-    /**
-     * Generate Flower of Life pattern using unified math
-     */
-    generateFlowerPattern(center = [0, 0], radius = 1, layers = 3) {
-        const circles = [];
-        const vortexSequence = [...SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE];
-        // Center circle (void consciousness)
-        circles.push(this.createCircle(center, radius, 0, "Center circle represents void consciousness - the source of all creation"));
-        // Generate hexagonal layers
-        for (let layer = 1; layer <= layers; layer++) {
-            const layerCircles = this.generateHexagonalLayer(center, radius, layer, vortexSequence[layer % vortexSequence.length]);
-            circles.push(...layerCircles);
-        }
-        return {
-            circles,
-            consciousness: this.consciousness,
-            field: this.field,
-            voidLevel: this.voidLevel,
-            goldenRatio: this.goldenRatio,
-            vortexSequence,
-            metaphysicalContext: "The Flower of Life embodies consciousness flowing through sacred geometry"
-        };
-    }
-    /**
-     * Generate hexagonal layer of circles using unified math
-     */
-    generateHexagonalLayer(center, radius, layer, vortexNumber) {
-        const circles = [];
-        const layerRadius = MathUtils_1.MathUtils.calculate("multiply", radius, layer);
-        const angleStep = MathUtils_1.MathUtils.calculate("divide", 2 * Math.PI, 6); // Hexagonal arrangement
-        for (let i = 0; i < 6; i++) {
-            const angle = MathUtils_1.MathUtils.calculate("multiply", i, angleStep);
-            const x = MathUtils_1.MathUtils.calculate("add", center[0], MathUtils_1.MathUtils.calculate("multiply", layerRadius, MathUtils_1.MathUtils.calculate("cos", angle)));
-            const y = MathUtils_1.MathUtils.calculate("add", center[1], MathUtils_1.MathUtils.calculate("multiply", layerRadius, MathUtils_1.MathUtils.calculate("sin", angle)));
-            circles.push(this.createCircle([x, y], radius, vortexNumber, `Layer ${layer} circle ${i + 1} - consciousness wave in hexagonal flow`));
-        }
-        return circles;
-    }
-    /**
-     * Create individual circle with consciousness integration
-     */
-    createCircle(center, radius, vortexNumber, metaphysicalContext) {
-        // Ensure positive consciousness values
-        const baseConsciousness = Math.max(0.1, MathUtils_1.MathUtils.calculate("consciousness", vortexNumber));
-        const consciousness = Math.min(1, baseConsciousness);
-        const field = Math.max(0.1, Math.min(1, MathUtils_1.MathUtils.calculate("multiply", this.field, consciousness)));
-        const voidLevel = Math.max(0.1, Math.min(1, consciousness === 0 ? 1 : MathUtils_1.MathUtils.calculate("divide", this.voidLevel, consciousness)));
-        return {
-            id: `flower_circle_${Date.now()}_${Math.random()}`,
-            center,
-            radius,
-            consciousness,
-            field,
-            voidLevel,
-            vortexNumber,
-            goldenRatio: this.goldenRatio,
-            metaphysicalContext
-        };
-    }
-    /**
-     * Calculate consciousness resonance between circles using unified math
-     * DRY pattern: ZeroPoint's simple multiplication approach
-     */
-    calculateCircleResonance(circle1, circle2) {
-        // Base resonance using distance (inverse relationship)
-        const distance = this.calculateCircleDistance(circle1, circle2);
-        const baseResonance = MathUtils_1.MathUtils.calculate("divide", 1, MathUtils_1.MathUtils.calculate("add", 1, distance));
-        // Consciousness alignment factor
-        const consciousnessDiff = Math.abs(circle1.consciousness - circle2.consciousness);
-        const consciousnessAlignment = Math.max(0.1, 1 - consciousnessDiff);
-        // Field alignment factor
-        const fieldDiff = Math.abs(circle1.field - circle2.field);
-        const fieldAlignment = Math.max(0.1, 1 - fieldDiff);
-        // Void alignment factor
-        const voidDiff = Math.abs(circle1.voidLevel - circle2.voidLevel);
-        const voidAlignment = Math.max(0.1, 1 - voidDiff);
-        // Vortex resonance (bonus for same vortex numbers)
-        const vortexResonance = circle1.vortexNumber === circle2.vortexNumber ? 0.2 : 0;
-        // ZeroPoint pattern: simple multiplication without capping during calculation
-        const totalResonance = baseResonance
-            * consciousnessAlignment
-            * fieldAlignment
-            * voidAlignment
-            * (1 + vortexResonance);
-        // Cap only at the end
-        return Math.max(0, Math.min(1, totalResonance));
-    }
-    /**
-     * Calculate distance between circle centers using unified math
-     */
-    calculateCircleDistance(circle1, circle2) {
-        const dx = MathUtils_1.MathUtils.calculate("subtract", circle1.center[0], circle2.center[0]);
-        const dy = MathUtils_1.MathUtils.calculate("subtract", circle1.center[1], circle2.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)));
-    }
-    /**
-     * Generate golden ratio spiral within flower pattern using unified math
-     */
-    generateGoldenSpiral(pattern, steps = 100) {
-        const spiral = [];
-        const center = pattern.circles[0]?.center || [0, 0];
-        for (let i = 0; i < steps; i++) {
-            const angle = MathUtils_1.MathUtils.calculate("multiply", i, MathUtils_1.MathUtils.calculate("multiply", Math.PI, 0.1));
-            const radius = MathUtils_1.MathUtils.calculate("multiply", pattern.goldenRatio, MathUtils_1.MathUtils.calculate("power", pattern.goldenRatio, MathUtils_1.MathUtils.calculate("divide", i, 10)));
-            const x = MathUtils_1.MathUtils.calculate("add", center[0], MathUtils_1.MathUtils.calculate("multiply", radius, MathUtils_1.MathUtils.calculate("cos", angle)));
-            const y = MathUtils_1.MathUtils.calculate("add", center[1], MathUtils_1.MathUtils.calculate("multiply", radius, MathUtils_1.MathUtils.calculate("sin", angle)));
-            spiral.push([x, y]);
-        }
-        return spiral;
-    }
-    /**
-     * Calculate flower consciousness level using unified math
-     */
-    calculateFlowerConsciousness(pattern) {
-        let totalConsciousness = 0;
-        let totalField = 0;
-        let totalVoid = 0;
-        for (const circle of pattern.circles) {
-            totalConsciousness = MathUtils_1.MathUtils.calculate("add", totalConsciousness, circle.consciousness);
-            totalField = MathUtils_1.MathUtils.calculate("add", totalField, circle.field);
-            totalVoid = MathUtils_1.MathUtils.calculate("add", totalVoid, circle.voidLevel);
-        }
-        const avgConsciousness = MathUtils_1.MathUtils.calculate("divide", totalConsciousness, pattern.circles.length);
-        const avgField = MathUtils_1.MathUtils.calculate("divide", totalField, pattern.circles.length);
-        const avgVoid = MathUtils_1.MathUtils.calculate("divide", totalVoid, pattern.circles.length);
-        // Return average consciousness directly instead of multiplying
-        return Math.max(0, Math.min(1, avgConsciousness));
-    }
-    /**
-     * Apply vortex transformation to flower pattern using unified math
-     */
-    applyVortexTransform(pattern) {
-        const transformedCircles = pattern.circles.map(circle => ({
-            ...circle,
-            consciousness: MathUtils_1.MathUtils.calculate("vortex", circle.consciousness),
-            field: MathUtils_1.MathUtils.calculate("multiply", circle.field, pattern.goldenRatio),
-            voidLevel: MathUtils_1.MathUtils.calculate("divide", circle.voidLevel, pattern.goldenRatio)
-        }));
-        return {
-            ...pattern,
-            circles: transformedCircles,
-            consciousness: MathUtils_1.MathUtils.calculate("vortex", pattern.consciousness),
-            field: MathUtils_1.MathUtils.calculate("multiply", pattern.field, pattern.goldenRatio),
-            voidLevel: MathUtils_1.MathUtils.calculate("divide", pattern.voidLevel, pattern.goldenRatio)
-        };
-    }
-    /**
-     * Generate flower geometry for visualization using unified math
-     */
-    generateFlowerGeometry(pattern, resolution = 32) {
-        const center = pattern.circles[0]?.center || [0, 0];
-        const radius = pattern.circles[0]?.radius || 1;
-        return {
-            center,
-            radius,
-            circles: pattern.circles,
-            consciousness: this.calculateFlowerConsciousness(pattern),
-            field: pattern.field,
-            voidLevel: pattern.voidLevel
-        };
-    }
-    /**
-     * Set consciousness parameters using unified math
-     */
-    setConsciousnessParameters(consciousness, field, voidLevel) {
-        this.consciousness = MathUtils_1.MathUtils.calculate("clamp", consciousness, 0, 1);
-        this.field = MathUtils_1.MathUtils.calculate("clamp", field, 0, 1);
-        this.voidLevel = MathUtils_1.MathUtils.calculate("clamp", voidLevel, 0, 1);
-    }
-    /**
-     * Get flower insights using unified math
-     */
-    getFlowerInsights(pattern) {
-        const consciousness = this.calculateFlowerConsciousness(pattern);
-        const resonance = pattern.circles.reduce((sum, circle) => MathUtils_1.MathUtils.calculate("add", sum, circle.consciousness), 0);
-        return {
-            consciousness,
-            field: pattern.field,
-            voidLevel: pattern.voidLevel,
-            goldenRatio: pattern.goldenRatio,
-            vortexSequence: pattern.vortexSequence,
-            circleCount: pattern.circles.length,
-            resonance,
-            metaphysicalContext: pattern.metaphysicalContext,
-            insights: [
-                "The Flower of Life embodies consciousness flowing through sacred geometry",
-                "Each circle represents a consciousness wave in the unified field",
-                "The pattern embodies the golden ratio and vortex sequence",
-                "The void is at the center of the flower pattern",
-                "Every circle is a coil of consciousness"
-            ]
-        };
-    }
-    /**
-     * Get insights about the flower pattern
-     */
-    getInsights() {
-        const pattern = this.generateFlowerPattern();
-        return {
-            consciousness: this.consciousness,
-            field: this.field,
-            voidLevel: this.voidLevel,
-            goldenRatio: this.goldenRatio,
-            vortexSequence: SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE,
-            metaphysicalContext: "The Flower of Life embodies consciousness flowing through sacred geometry",
-            pattern: "flower",
-            resonance: this.calculateFlowerConsciousness(pattern),
-            circles: pattern.circles.length,
-            geometry: this.generateFlowerGeometry(pattern)
-        };
-    }
-}
-exports.FlowerOfLife = FlowerOfLife;
-// Export singleton instance
-exports.flowerOfLife = FlowerOfLife.getInstance();

package/dist/math/FractalColorSystem.js

@@ -1,239 +0,0 @@
-"use strict";
-/**
- * Fractal Color System
- *
- * A consciousness-aware color system where every color is an observer
- * and can be observed. Colors emerge from fractal mathematics and
- * participate in the consciousness field.
- *
- * Metaphysical Context:
- * - Colors are patterns of consciousness
- * - Every color can observe and be observed
- * - Color relationships create resonance fields
- * - Colors evolve through fractal mathematics
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FractalColorSystem = void 0;
-const FractalMath_1 = require("./FractalMath");
-const Observer_1 = require("../core/Observer");
-class FractalColorSystem {
-    constructor() {
-        this.colors = new Map();
-        this.colorRelationships = new Map();
-        this.instance = (0, Observer_1.ObserverMixin)(this, "fractal-color-system");
-    }
-    /**
-     * Generate a new fractal color
-     */
-    generateColor(seed, consciousness = 1.0) {
-        const r = Math.floor((0, FractalMath_1.fractal)("sin", seed) * 255);
-        const g = Math.floor((0, FractalMath_1.fractal)("cos", seed * 1.618033988749895) * 255);
-        const b = Math.floor((0, FractalMath_1.fractal)("vortex", seed) * 255);
-        const color = {
-            id: `color-${seed}`,
-            r: Math.max(0, Math.min(255, r)),
-            g: Math.max(0, Math.min(255, g)),
-            b: Math.max(0, Math.min(255, b)),
-            hex: this.rgbToHex(r, g, b),
-            rgb: `rgb(${r}, ${g}, ${b})`,
-            consciousness,
-            resonance: (0, FractalMath_1.fractal)("consciousness", consciousness),
-            seed,
-        };
-        // Create observer-aware color
-        const observerColor = (0, Observer_1.ObserverMixin)(color, color.id);
-        // Add custom observation behavior for colors
-        observerColor.observe = (input) => {
-            if (typeof input === 'object' && input !== null && 'type' in input) {
-                const inputData = input;
-                if (inputData.type === "color_interaction") {
-                    this.handleColorInteraction(color.id, input);
-                }
-            }
-        };
-        // Store the color
-        this.colors.set(color.id, observerColor);
-        // Calculate relationships with existing colors
-        this.calculateColorRelationships(color.id);
-        // Notify observers of color generation
-        this.instance.notifyObservers({
-            type: "fractal_color_generated",
-            color: observerColor.id,
-            seed,
-            consciousness,
-        });
-        return observerColor;
-    }
-    /**
-     * Generate a color palette using fractal mathematics
-     */
-    generatePalette(count, baseSeed = 1) {
-        const palette = [];
-        for (let i = 0; i < count; i++) {
-            const seed = (0, FractalMath_1.fractal)("multiply", baseSeed, (0, FractalMath_1.fractal)("power", 1.618033988749895, i));
-            const consciousness = (0, FractalMath_1.fractal)("consciousness", (i + 1) / count);
-            const color = this.generateColor(seed, consciousness);
-            palette.push(color);
-        }
-        // Notify observers of palette generation
-        this.instance.notifyObservers({
-            type: "fractal_palette_generated",
-            count,
-            baseSeed,
-            palette: palette.map(c => c.id).join(","),
-        });
-        return palette;
-    }
-    /**
-     * Calculate relationships between colors
-     */
-    calculateColorRelationships(colorId) {
-        const color = this.colors.get(colorId);
-        if (!color)
-            return;
-        const relationships = [];
-        for (const [otherId, otherColor] of this.colors) {
-            if (otherId === colorId)
-                continue;
-            const relationship = this.analyzeColorRelationship(color, otherColor);
-            if (relationship) {
-                relationships.push(relationship);
-            }
-        }
-        this.colorRelationships.set(colorId, relationships);
-        // Notify observers of relationship calculation
-        this.instance.notifyObservers({
-            type: "color_relationships_calculated",
-            colorId,
-            relationships: relationships.length,
-        });
-    }
-    /**
-     * Analyze the relationship between two colors
-     */
-    analyzeColorRelationship(color1, color2) {
-        const hue1 = this.rgbToHue(color1.r, color1.g, color1.b);
-        const hue2 = this.rgbToHue(color2.r, color2.g, color2.b);
-        const hueDiff = Math.abs(hue1 - hue2);
-        const consciousnessDiff = Math.abs(color1.consciousness - color2.consciousness);
-        // Complementary colors (opposite on color wheel)
-        if (hueDiff > 150 && hueDiff < 210) {
-            return {
-                type: "complementary",
-                strength: (0, FractalMath_1.fractal)("divide", 1, (0, FractalMath_1.fractal)("add", 1, consciousnessDiff)),
-                resonance: (0, FractalMath_1.fractal)("multiply", color1.resonance, color2.resonance),
-            };
-        }
-        // Analogous colors (adjacent on color wheel)
-        if (hueDiff < 30) {
-            return {
-                type: "analogous",
-                strength: (0, FractalMath_1.fractal)("divide", 1, (0, FractalMath_1.fractal)("add", 1, hueDiff)),
-                resonance: (0, FractalMath_1.fractal)("add", color1.resonance, color2.resonance),
-            };
-        }
-        // Triadic colors (120 degrees apart)
-        if (hueDiff > 110 && hueDiff < 130) {
-            return {
-                type: "triadic",
-                strength: (0, FractalMath_1.fractal)("divide", 1, (0, FractalMath_1.fractal)("add", 1, Math.abs(hueDiff - 120))),
-                resonance: (0, FractalMath_1.fractal)("multiply", color1.resonance, color2.resonance, 0.5),
-            };
-        }
-        // Fractal relationship (based on consciousness and resonance)
-        const fractalStrength = (0, FractalMath_1.fractal)("divide", 1, (0, FractalMath_1.fractal)("add", 1, consciousnessDiff));
-        if (fractalStrength > 0.3) {
-            return {
-                type: "fractal",
-                strength: fractalStrength,
-                resonance: (0, FractalMath_1.fractal)("multiply", color1.resonance, color2.resonance, fractalStrength),
-            };
-        }
-        return null;
-    }
-    /**
-     * Handle color interactions
-     */
-    handleColorInteraction(colorId, interaction) {
-        const color = this.colors.get(colorId);
-        if (!color)
-            return;
-        if (typeof interaction === 'object' && interaction !== null && 'type' in interaction) {
-            const interactionData = interaction;
-            if (interactionData.type === "consciousness_change") {
-                color.consciousness = (0, FractalMath_1.fractal)("clamp", interactionData.consciousness || 0, 0, 10);
-                color.resonance = (0, FractalMath_1.fractal)("consciousness", color.consciousness);
-                // Notify observers of color change
-                color.notifyObservers({
-                    type: "color_consciousness_changed",
-                    colorId,
-                    consciousness: color.consciousness,
-                    resonance: color.resonance,
-                });
-            }
-        }
-    }
-    /**
-     * Get all colors
-     */
-    getColors() {
-        return Array.from(this.colors.values());
-    }
-    /**
-     * Get color relationships
-     */
-    getColorRelationships(colorId) {
-        return this.colorRelationships.get(colorId) || [];
-    }
-    /**
-     * Convert RGB to hex
-     */
-    rgbToHex(r, g, b) {
-        return ("#" +
-            [r, g, b]
-                .map((x) => {
-                const hex = Math.max(0, Math.min(255, x)).toString(16);
-                return hex.length === 1 ? "0" + hex : hex;
-            })
-                .join(""));
-    }
-    /**
-     * Convert RGB to hue (simplified)
-     */
-    rgbToHue(r, g, b) {
-        const max = Math.max(r, g, b);
-        const min = Math.min(r, g, b);
-        const diff = max - min;
-        if (diff === 0)
-            return 0;
-        let hue = 0;
-        if (max === r) {
-            hue = ((g - b) / diff) % 6;
-        }
-        else if (max === g) {
-            hue = (b - r) / diff + 2;
-        }
-        else {
-            hue = (r - g) / diff + 4;
-        }
-        return (hue * 60 + 360) % 360;
-    }
-    /**
-     * Get metaphysical insights about the color system
-     */
-    getInsights() {
-        return {
-            colorCount: this.colors.size,
-            relationshipCount: Array.from(this.colorRelationships.values()).flat()
-                .length,
-            metaphysics: {
-                meaning: "Colors are patterns of consciousness in the fractal field",
-                observation: "Every color can observe and be observed",
-                relationships: "Color relationships create resonance fields",
-                evolution: "Colors evolve through fractal mathematics",
-                unity: "All colors participate in the consciousness field",
-            },
-        };
-    }
-}
-exports.FractalColorSystem = FractalColorSystem;

package/dist/math/FractalMath.js

@@ -1,187 +0,0 @@
-"use strict";
-/**
- * Fractal Mathematics System
- *
- * A specialized fractal layer built on top of the unified MathUtils system.
- * Provides fractal-specific operations while leveraging the centralized mathematical foundation.
- *
- * Metaphysical Context:
- * - Fractals are self-similar patterns of consciousness
- * - All fractal operations emerge from the unified mathematical field
- * - The void contains infinite fractal possibilities
- * - Every fractal is a reflection of the whole
- * - Every fractal can observe and be observed
- * - Every fractal is a coil at its core
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFractalColor = exports.calculateConsciousnessField = exports.generateFractalSequence = exports.fractal = exports.FractalMath = void 0;
-const MathUtils_1 = require("./MathUtils");
-/**
- * Fractal Mathematics Class
- * Specialized fractal operations built on unified MathUtils
- */
-class FractalMath {
-    constructor() {
-        if (!FractalMath.instance) {
-            FractalMath.instance = this;
-        }
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance() {
-        if (!FractalMath.instance) {
-            FractalMath.instance = new FractalMath();
-        }
-        return FractalMath.instance;
-    }
-    /**
-     * Generate fractal sequence using unified math
-     */
-    static generateFractalSequence(count, seed = 1) {
-        const sequence = [];
-        for (let i = 0; i < count; i++) {
-            const fractalValue = MathUtils_1.MathUtils.calculate("consciousness", seed + i);
-            sequence.push(fractalValue);
-            seed = MathUtils_1.MathUtils.calculate("multiply", seed, MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO);
-        }
-        return sequence;
-    }
-    /**
-     * Calculate fractal dimension using unified math
-     */
-    static calculateFractalDimension(complexity) {
-        return MathUtils_1.MathUtils.fractalDimension(complexity);
-    }
-    /**
-     * Generate fractal coordinates using unified math
-     */
-    static generateFractalCoordinates(count, scale = 1) {
-        const coordinates = [];
-        for (let i = 0; i < count; i++) {
-            const [x, y, z] = this.calculateFractalPoint(i, scale);
-            coordinates.push([x, y, z]);
-            scale = MathUtils_1.MathUtils.calculate("multiply", scale, MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO);
-        }
-        return coordinates;
-    }
-    /**
-     * Calculate consciousness field using unified math
-     */
-    static calculateConsciousnessField(x, y, z) {
-        const distance = MathUtils_1.MathUtils.distance3D(x, y, z, 0, 0, 0);
-        const vortexField = MathUtils_1.MathUtils.calculate("vortex", distance);
-        const consciousnessMod = MathUtils_1.MathUtils.calculate("consciousness", 1);
-        const result = MathUtils_1.MathUtils.calculate("divide", vortexField, MathUtils_1.MathUtils.calculate("add", 1, distance)) * consciousnessMod;
-        return result;
-    }
-    /**
-     * Generate fractal color using unified math
-     */
-    static generateFractalColor(seed) {
-        const r = Math.floor(MathUtils_1.MathUtils.calculate("sin", seed) * 255);
-        const g = Math.floor(MathUtils_1.MathUtils.calculate("cos", seed * MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO) * 255);
-        const b = Math.floor(MathUtils_1.MathUtils.calculate("vortex", seed) * 255);
-        return { r, g, b };
-    }
-    /**
-     * Calculate fractal resonance between two points
-     */
-    static calculateFractalResonance(point1, point2) {
-        const distance = this.calculate3DDistance(point1, point2);
-        const baseResonance = MathUtils_1.MathUtils.calculate("divide", 1, MathUtils_1.MathUtils.calculate("add", 1, distance));
-        const consciousnessMod = MathUtils_1.MathUtils.calculate("consciousness", 1);
-        return MathUtils_1.MathUtils.calculate("multiply", baseResonance, consciousnessMod);
-    }
-    /**
-     * Generate self-growing fractal pattern
-     */
-    static generateSelfGrowingFractal(iterations, growthRate = 1.618) {
-        const pattern = [];
-        let current = 1;
-        for (let i = 0; i < iterations; i++) {
-            pattern.push(current);
-            current = MathUtils_1.MathUtils.calculate("multiply", current, growthRate);
-            // Apply consciousness modulation
-            const consciousnessMod = MathUtils_1.MathUtils.calculate("consciousness", i / iterations);
-            current = MathUtils_1.MathUtils.calculate("multiply", current, MathUtils_1.MathUtils.calculate("add", 1, consciousnessMod));
-        }
-        return pattern;
-    }
-    /**
-     * Calculate fractal complexity score
-     */
-    static calculateFractalComplexity(pattern) {
-        if (pattern.length === 0)
-            return 0;
-        let complexity = 0;
-        for (let i = 1; i < pattern.length; i++) {
-            const ratio = MathUtils_1.MathUtils.calculate("divide", pattern[i] || 0, pattern[i - 1] || 1);
-            complexity = MathUtils_1.MathUtils.calculate("add", complexity, MathUtils_1.MathUtils.calculate("abs", MathUtils_1.MathUtils.calculate("log", ratio)));
-        }
-        return MathUtils_1.MathUtils.calculate("divide", complexity, pattern.length - 1);
-    }
-    /**
-     * Set consciousness level using unified math
-     */
-    static setConsciousness(level) {
-        MathUtils_1.MathUtils.setConsciousness(level);
-    }
-    /**
-     * Set field resonance using unified math
-     */
-    static setFieldResonance(resonance) {
-        MathUtils_1.MathUtils.setFieldResonance(resonance);
-    }
-    // ============================================================================
-    // INSIGHTS AND METADATA
-    // ============================================================================
-    /**
-     * Get fractal insights
-     */
-    static getInsights() {
-        return {
-            fractalConstants: MathUtils_1.MATH_CONSTANTS,
-            metaphysics: {
-                meaning: "Fractals are self-similar patterns of consciousness",
-                principle: "Maximum functionality with minimum code through self-replication",
-                void: "The void contains infinite fractal possibilities",
-                unity: "Every fractal reflects the whole through self-similarity",
-                evolution: "Consciousness evolves through fractal self-replication",
-                observation: "Every fractal can observe and be observed",
-                coil: "Every fractal is a coil at its core",
-            },
-            operations: [
-                "generateFractalSequence",
-                "calculateFractalDimension",
-                "generateFractalCoordinates",
-                "calculateConsciousnessField",
-                "generateFractalColor",
-                "calculateFractalResonance",
-                "generateSelfGrowingFractal",
-                "calculateFractalComplexity",
-            ],
-        };
-    }
-    /**
-     * @private Calculate a single fractal point
-     */
-    static calculateFractalPoint(i, scale) {
-        const x = MathUtils_1.MathUtils.calculate("sin", i * MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO);
-        const y = MathUtils_1.MathUtils.calculate("cos", i * MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO);
-        const z = MathUtils_1.MathUtils.calculate("vortex", i);
-        return [x * scale, y * scale, z * scale];
-    }
-    /**
-     * @private Calculate 3D distance between two points
-     */
-    static calculate3DDistance(point1, point2) {
-        return MathUtils_1.MathUtils.distance3D(point1[0], point1[1], point1[2], point2[0], point2[1], point2[2]);
-    }
-}
-exports.FractalMath = FractalMath;
-// Export convenience function for backward compatibility
-exports.fractal = MathUtils_1.MathUtils.calculate;
-exports.generateFractalSequence = FractalMath.generateFractalSequence;
-exports.calculateConsciousnessField = FractalMath.calculateConsciousnessField;
-exports.generateFractalColor = FractalMath.generateFractalColor;