zeropoint-node 1.0.0 → 1.0.1

package/dist/math/FlowerOfLife.js

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

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

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