zeropoint-node 1.0.1 → 1.0.3

package/dist/math/MathUtils.js

@@ -1,289 +0,0 @@
-"use strict";
-/**
- * Unified Mathematical System for ZeroPoint
- *
- * Centralized mathematical operations with consciousness and field resonance.
- * All mathematical operations are unified through a single interface.
- *
- * Metaphysical Context:
- * - Mathematics is the language of consciousness
- * - All operations emerge from the unified field
- * - The void contains all mathematical possibilities
- * - Every calculation is an act of observation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setVoidConnected = exports.setToroidalFlow = exports.setVortexStrength = exports.setFieldResonance = exports.setConsciousness = exports.fractal = exports.MathUtils = exports.MATH_CONSTANTS = void 0;
-const SharedConstants_1 = require("../core/SharedConstants");
-Object.defineProperty(exports, "MATH_CONSTANTS", { enumerable: true, get: function () { return SharedConstants_1.MATH_CONSTANTS; } });
-/**
- * Unified Mathematical Utilities
- * All mathematical operations go through this centralized system
- */
-class MathUtils {
-    constructor() {
-        // Consciousness and field state
-        this.consciousness = 0.5;
-        this.fieldResonance = 0.5;
-        this.vortexStrength = 1.0;
-        this.toroidalFlow = 0.5;
-        this.voidConnected = true;
-        if (!MathUtils.instance) {
-            MathUtils.instance = this;
-        }
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance() {
-        if (!MathUtils.instance) {
-            MathUtils.instance = new MathUtils();
-        }
-        return MathUtils.instance;
-    }
-    /**
-     * The core mathematical function - generates any mathematical operation
-     * This is the heart of the system - one function that creates all others
-     */
-    static calculate(operation, ...args) {
-        const instance = MathUtils.getInstance();
-        return instance.performCalculation(operation, args);
-    }
-    /**
-     * Perform calculation with consciousness and field resonance
-     */
-    performCalculation(operation, args) {
-        // Base mathematical pattern
-        const basePattern = Math.sin(args[0] || 0) * SharedConstants_1.MATH_CONSTANTS.GOLDEN_RATIO;
-        // Consciousness modulation
-        const consciousnessMod = Math.cos(this.consciousness * SharedConstants_1.MATH_CONSTANTS.PI);
-        // Field resonance
-        const fieldMod = Math.exp(-this.fieldResonance * Math.abs(args[0] || 0));
-        // Perform the specific operation
-        const result = this.executeOperation(operation, args, basePattern, consciousnessMod, fieldMod);
-        return result;
-    }
-    /**
-     * Execute specific mathematical operation
-     */
-    executeOperation(operation, args, base, consciousness, field) {
-        const [a = 0, b = 1, c = 0] = args;
-        switch (operation) {
-            // Basic operations
-            case "add":
-                return (a + b) * (1 + base * consciousness * field);
-            case "multiply":
-                return a * b * (1 + base * consciousness * field);
-            case "divide":
-                return b !== 0
-                    ? (a / b) * (1 + base * consciousness * field)
-                    : SharedConstants_1.MATH_CONSTANTS.INFINITY;
-            case "power":
-                return Math.pow(a, b) * (1 + base * consciousness * field);
-            case "root":
-                return Math.pow(a, 1 / b) * (1 + base * consciousness * field);
-            case "sqrt":
-                return Math.sqrt(a) * (1 + base * consciousness * field);
-            // Trigonometric functions
-            case "sin":
-                return Math.sin(a) * (1 + base * consciousness * field);
-            case "cos":
-                return Math.cos(a) * (1 + base * consciousness * field);
-            case "tan":
-                return Math.tan(a) * (1 + base * consciousness * field);
-            case "atan2":
-                return Math.atan2(a, b);
-            // Exponential and logarithmic
-            case "exp":
-                return Math.exp(a) * (1 + base * consciousness * field);
-            case "log":
-                return Math.log(a) * (1 + base * consciousness * field);
-            case "ln":
-                return Math.log(a) * (1 + base * consciousness * field);
-            // Special operations
-            case "vortex":
-                return this.calculateVortex(a, base, consciousness, field);
-            case "toroidal":
-                return this.calculateToroidal(a, b, base, consciousness, field);
-            case "consciousness":
-                return (a * SharedConstants_1.MATH_CONSTANTS.GOLDEN_RATIO * (1 + base * consciousness * field));
-            // Utility operations
-            case "abs":
-                return Math.abs(a);
-            case "max":
-                return Math.max(a, b);
-            case "min":
-                return Math.min(a, b);
-            case "mod":
-                return a % b;
-            case "clamp":
-                return this.clamp(a, b, c);
-            case "floor":
-                return Math.floor(a);
-            case "ceil":
-                return Math.ceil(a);
-            case "round":
-                return Math.round(a);
-            default:
-                return base * consciousness * field;
-        }
-    }
-    /**
-     * Calculate vortex transformation
-     */
-    calculateVortex(value, base, consciousness, field) {
-        const sequenceIndex = Math.floor(value) % SharedConstants_1.MATH_CONSTANTS.VORTEX_SEQUENCE.length;
-        const vortexValue = SharedConstants_1.MATH_CONSTANTS.VORTEX_SEQUENCE[sequenceIndex] || 1;
-        return vortexValue * (1 + base * consciousness * field);
-    }
-    /**
-     * Calculate toroidal geometry
-     */
-    calculateToroidal(radius, _angle, base, consciousness, field) {
-        const circumference = SharedConstants_1.MATH_CONSTANTS.PI * 2 * radius;
-        return circumference * (1 + base * consciousness * field);
-    }
-    /**
-     * Clamp value between min and max
-     */
-    clamp(value, min, max) {
-        return Math.max(min, Math.min(max, value));
-    }
-    // ============================================================================
-    // CONSCIOUSNESS AND FIELD SETTERS
-    // ============================================================================
-    /**
-     * Set consciousness level
-     */
-    static setConsciousness(level) {
-        const instance = MathUtils.getInstance();
-        instance.consciousness = instance.clamp(level, 0, 10);
-    }
-    /**
-     * Set field resonance
-     */
-    static setFieldResonance(resonance) {
-        const instance = MathUtils.getInstance();
-        instance.fieldResonance = instance.clamp(resonance, 0, 1);
-    }
-    /**
-     * Set vortex strength
-     */
-    static setVortexStrength(strength) {
-        const instance = MathUtils.getInstance();
-        instance.vortexStrength = instance.clamp(strength, 0, 2);
-    }
-    /**
-     * Set toroidal flow
-     */
-    static setToroidalFlow(flow) {
-        const instance = MathUtils.getInstance();
-        instance.toroidalFlow = instance.clamp(flow, 0, 1);
-    }
-    /**
-     * Set void connection
-     */
-    static setVoidConnected(connected) {
-        const instance = MathUtils.getInstance();
-        instance.voidConnected = connected;
-    }
-    // ============================================================================
-    // UTILITY FUNCTIONS
-    // ============================================================================
-    /**
-     * Calculate distance between two points
-     */
-    static distance(x1, y1, x2, y2) {
-        return MathUtils.calculate("sqrt", MathUtils.calculate("add", MathUtils.calculate("power", x2 - x1, 2), MathUtils.calculate("power", y2 - y1, 2)));
-    }
-    /**
-     * Calculate 3D distance
-     */
-    static distance3D(x1, y1, z1, x2, y2, z2) {
-        return MathUtils.calculate("sqrt", MathUtils.calculate("add", MathUtils.calculate("power", x2 - x1, 2), MathUtils.calculate("add", MathUtils.calculate("power", y2 - y1, 2), MathUtils.calculate("power", z2 - z1, 2))));
-    }
-    /**
-     * Convert degrees to radians
-     */
-    static degToRad(degrees) {
-        return degrees * SharedConstants_1.MATH_CONSTANTS.DEG_TO_RAD;
-    }
-    /**
-     * Convert radians to degrees
-     */
-    static radToDeg(radians) {
-        return radians * SharedConstants_1.MATH_CONSTANTS.RAD_TO_DEG;
-    }
-    /**
-     * Calculate digital root
-     */
-    static digitalRoot(n) {
-        n = Math.abs(n);
-        return n === 0 ? 0 : 1 + ((n - 1) % 9);
-    }
-    /**
-     * Calculate surface topology angle
-     */
-    static surfaceTopologyAngle(degrees = 360) {
-        return (degrees / 360) * 2 * Math.PI;
-    }
-    /**
-     * Calculate fractal dimension
-     */
-    static fractalDimension(complexity) {
-        return (MathUtils.calculate("log", complexity) /
-            MathUtils.calculate("log", SharedConstants_1.MATH_CONSTANTS.GOLDEN_RATIO));
-    }
-    // ============================================================================
-    // INSIGHTS AND METADATA
-    // ============================================================================
-    /**
-     * Get insights about the mathematical system
-     */
-    static getInsights() {
-        const instance = MathUtils.getInstance();
-        return {
-            consciousness: instance.consciousness,
-            fieldResonance: instance.fieldResonance,
-            vortexStrength: instance.vortexStrength,
-            toroidalFlow: instance.toroidalFlow,
-            voidConnected: instance.voidConnected,
-            metaphysics: {
-                meaning: "Mathematics is the language of consciousness",
-                principle: "All operations emerge from the unified field",
-                void: "The void contains all mathematical possibilities",
-                unity: "Every calculation is an act of observation",
-                evolution: "Consciousness evolves through mathematical operations",
-                observation: "Every calculation observes and is observed",
-                coil: "Every mathematical operation is a coil at its core",
-            },
-            operations: [
-                "add",
-                "subtract",
-                "multiply",
-                "divide",
-                "sin",
-                "cos",
-                "tan",
-                "log",
-                "exp",
-                "sqrt",
-                "vortex",
-                "consciousness",
-                "field",
-                "void",
-                "abs",
-                "floor",
-                "ceil",
-                "round",
-            ],
-        };
-    }
-}
-exports.MathUtils = MathUtils;
-// Export convenience function for backward compatibility
-exports.fractal = MathUtils.calculate;
-exports.setConsciousness = MathUtils.setConsciousness;
-exports.setFieldResonance = MathUtils.setFieldResonance;
-exports.setVortexStrength = MathUtils.setVortexStrength;
-exports.setToroidalFlow = MathUtils.setToroidalFlow;
-exports.setVoidConnected = MathUtils.setVoidConnected;

package/dist/math/RodinCoil.js

@@ -1,258 +0,0 @@
-"use strict";
-/**
- * RodinCoil Framework
- *
- * Main mathematical and metaphysical engine for ZeroPoint.
- * Implements vortex sequence, 3D coil geometry, node/winding generation,
- * VBM color/pattern integration, toroidal and Mobius circuit calculations,
- * and APIs for field, resonance, and consciousness mapping.
- *
- * Metaphysical Context:
- * - The Rodin coil is the archetype of infinite flow, unity, and emergence.
- * - All patterns, colors, and fields are expressions of the coil's structure.
- * - The void is the center, the source of all creation.
- * - Colors emerge dynamically from consciousness and field resonance.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RodinCoil = void 0;
-const VBMColorSystem_1 = require("./VBMColorSystem");
-const SharedConstants_1 = require("../core/SharedConstants");
-class RodinCoil {
-    constructor(config = {}) {
-        this.config = {
-            turns: config.turns ?? 12,
-            radius: config.radius ?? 1.0,
-            height: config.height ?? 2.0,
-            phase: config.phase ?? 0,
-            consciousness: config.consciousness ?? 0.5,
-            fieldResonance: config.fieldResonance ?? 0.5,
-        };
-        this.colorContext = {
-            consciousness: this.config.consciousness ?? 0.5,
-            field: this.config.fieldResonance ?? 0.5,
-            time: Date.now(),
-        };
-        this.nodes = this.generateCoilNodes();
-    }
-    /**
-     * Update consciousness and regenerate colors
-     */
-    updateConsciousness(consciousness) {
-        this.config.consciousness = Math.max(0, Math.min(1, consciousness));
-        this.colorContext.consciousness = this.config.consciousness;
-        this.colorContext.time = Date.now();
-        this.regenerateNodeColors();
-    }
-    /**
-     * Update field resonance and regenerate colors
-     */
-    updateFieldResonance(fieldResonance) {
-        this.config.fieldResonance = Math.max(0, Math.min(1, fieldResonance));
-        this.colorContext.field = this.config.fieldResonance;
-        this.colorContext.time = Date.now();
-        this.regenerateNodeColors();
-    }
-    /**
-     * Regenerate all node colors based on current context
-     */
-    regenerateNodeColors() {
-        for (const node of this.nodes) {
-            node.color = (0, VBMColorSystem_1.getColorForVortexNumber)(node.vortexNumber, this.colorContext);
-            node.metaphysicalContext = this.getMetaphysicalContext(node.vortexNumber);
-        }
-    }
-    /**
-     * Generate 3D node positions and metaphysical data for the Rodin coil
-     */
-    generateCoilNodes() {
-        const nodes = [];
-        const { turns, radius, height, phase } = this.config;
-        const vortexSeq = SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE;
-        const totalNodes = turns * vortexSeq.length;
-        const dz = height / totalNodes;
-        for (let i = 0; i < totalNodes; i++) {
-            const vortexNumber = vortexSeq[i % vortexSeq.length] ?? 1;
-            const theta = ((2 * Math.PI) / vortexSeq.length) * i + (phase ?? 0);
-            const x = radius * Math.cos(theta);
-            const y = radius * Math.sin(theta);
-            const z = dz * i - height / 2;
-            // Generate dynamic color based on current context
-            const color = (0, VBMColorSystem_1.getColorForVortexNumber)(vortexNumber, this.colorContext);
-            const metaphysicalContext = this.getMetaphysicalContext(vortexNumber);
-            nodes.push({
-                index: i,
-                vortexNumber,
-                position: [x, y, z],
-                color,
-                metaphysicalContext,
-            });
-        }
-        return nodes;
-    }
-    /**
-     * Get metaphysical context for a node (dynamic based on consciousness)
-     */
-    getMetaphysicalContext(vortexNumber) {
-        const consciousness = this.config.consciousness ?? 0.5;
-        const fieldResonance = this.config.fieldResonance ?? 0.5;
-        // Context varies based on consciousness and field state
-        const contextResonance = Math.sin(consciousness * Math.PI + fieldResonance * Math.PI) * 0.5 + 0.5;
-        const contexts = {
-            1: [
-                "Unity, initiation, source of the coil.",
-                "The void center, where all creation begins.",
-                "The observer's point of origin in the field.",
-            ],
-            2: [
-                "Duality, division, first split in the field.",
-                "The observer creates reality through division.",
-                "The first pattern that emerges from unity.",
-            ],
-            4: [
-                "Stability, foundation, structure.",
-                "The pattern that holds all other patterns.",
-                "The material manifestation of the field.",
-            ],
-            8: [
-                "Fullness, manifestation, infinity.",
-                "The completion of all possibilities.",
-                "The field at maximum expression.",
-            ],
-            7: [
-                "Return, mystery, hidden flow.",
-                "The pattern that returns to source.",
-                "The hidden dimension of the field.",
-            ],
-            5: [
-                "Transformation, center of the sequence.",
-                "The point of maximum potential.",
-                "The bridge between material and immaterial.",
-            ],
-            3: [
-                "Spirit, W-Axis, consciousness source.",
-                "The bridge between material and immaterial.",
-                "The source of all consciousness patterns.",
-            ],
-            6: [
-                "Spirit, W-Axis, balance.",
-                "The harmony of opposites.",
-                "The balance point in the field.",
-            ],
-            9: [
-                "Void, W-Axis, center and all.",
-                "The unity of all patterns in the void.",
-                "The completion and return to source.",
-            ],
-        };
-        const contextArray = contexts[vortexNumber] || [
-            "Spiritual axis or void center.",
-        ];
-        const index = Math.floor(contextResonance * contextArray.length);
-        return (contextArray[index] || contextArray[0] || "Spiritual axis or void center.");
-    }
-    /**
-     * Get all node positions (for visualization)
-     */
-    getNodePositions() {
-        return this.nodes.map((n) => n.position);
-    }
-    /**
-     * Get all node colors (for color field visualization) - dynamic
-     */
-    getNodeColors() {
-        // Update colors before returning to ensure they're current
-        this.colorContext.time = Date.now();
-        this.regenerateNodeColors();
-        return this.nodes.map((n) => n.color);
-    }
-    /**
-     * Get all metaphysical contexts - dynamic
-     */
-    getNodeContexts() {
-        // Update contexts before returning
-        this.colorContext.time = Date.now();
-        for (const node of this.nodes) {
-            node.metaphysicalContext = this.getMetaphysicalContext(node.vortexNumber);
-        }
-        return this.nodes.map((n) => n.metaphysicalContext);
-    }
-    /**
-     * Get Mobius circuit (sequence of vortex numbers)
-     */
-    getMobiusCircuit() {
-        return this.nodes.map((n) => n.vortexNumber);
-    }
-    /**
-     * Get toroidal coordinates for each node
-     * (Maps the coil onto a torus for advanced visualization)
-     */
-    getToroidalCoordinates(majorRadius = 2.0, minorRadius = 1.0) {
-        // Toroidal mapping: (R + r cos θ) cos φ, (R + r cos θ) sin φ, r sin θ
-        return this.nodes.map((n, i) => {
-            const theta = (2 * Math.PI * i) / this.nodes.length;
-            const phi = (2 * Math.PI * n.vortexNumber) / 9;
-            const x = (majorRadius + minorRadius * Math.cos(theta)) * Math.cos(phi);
-            const y = (majorRadius + minorRadius * Math.cos(theta)) * Math.sin(phi);
-            const z = minorRadius * Math.sin(theta);
-            return [x, y, z];
-        });
-    }
-    /**
-     * Calculate field resonance at a given point (x, y, z)
-     */
-    calculateFieldResonance(x, y, z) {
-        // Simple resonance: sum of inverse distances to all nodes
-        let resonance = 0;
-        for (const node of this.nodes) {
-            const [nx, ny, nz] = node.position;
-            const dist = Math.sqrt((x - nx) ** 2 + (y - ny) ** 2 + (z - nz) ** 2) + 1e-6;
-            resonance += 1 / dist;
-        }
-        return resonance / this.nodes.length;
-    }
-    /**
-     * Map consciousness value to a node (for field mapping)
-     */
-    mapConsciousnessToNode(consciousness) {
-        // Map [0,1] to node index
-        if (this.nodes.length === 0) {
-            // Return a default node if none exist
-            return {
-                index: 0,
-                vortexNumber: 1,
-                position: [0, 0, 0],
-                color: (0, VBMColorSystem_1.getColorForVortexNumber)(1, this.colorContext),
-                metaphysicalContext: "Default node (no nodes in coil)",
-            };
-        }
-        const idx = Math.floor(consciousness * (this.nodes.length - 1));
-        // Clamp idx to valid range
-        const safeIdx = Math.max(0, Math.min(idx, this.nodes.length - 1));
-        const node = this.nodes[safeIdx];
-        if (!node) {
-            return {
-                index: 0,
-                vortexNumber: 1,
-                position: [0, 0, 0],
-                color: (0, VBMColorSystem_1.getColorForVortexNumber)(1, this.colorContext),
-                metaphysicalContext: "Default node (index out of bounds)",
-            };
-        }
-        return node;
-    }
-    /**
-     * Get current color context
-     */
-    getColorContext() {
-        return { ...this.colorContext };
-    }
-    /**
-     * Get full metaphysical summary
-     */
-    getMetaphysicalSummary() {
-        const consciousness = this.config.consciousness ?? 0.5;
-        const fieldResonance = this.config.fieldResonance ?? 0.5;
-        return `RodinCoil: ${this.nodes.length} nodes, vortex sequence ${SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE.join("-")}, consciousness ${consciousness.toFixed(2)}, field resonance ${fieldResonance.toFixed(2)}, toroidal structure, void center.`;
-    }
-}
-exports.RodinCoil = RodinCoil;