zeropoint-node 1.0.0 → 1.0.1

package/dist/math/VBMColorSystem.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * VBMColorSystem
+ *
+ * Dynamic color generation system for Vortex-Based Mathematics (VBM).
+ * All colors are generated as functions based on context, parameters, and consciousness state.
+ * No hardcoded static values - colors emerge from the field of possibilities.
+ *
+ * Metaphysical Context:
+ * - Colors are expressions of consciousness patterns
+ * - Each color function responds to the observer's state
+ * - The void generates all colors through resonance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBaseColors = generateBaseColors;
+exports.getColorForVortexNumber = getColorForVortexNumber;
+exports.getColorForFamilyGroup = getColorForFamilyGroup;
+exports.getColorForPolarMate = getColorForPolarMate;
+exports.getColorForWAxis = getColorForWAxis;
+exports.getColorForPattern = getColorForPattern;
+exports.getMetaphysicalContextForNumber = getMetaphysicalContextForNumber;
+exports.getVBMColorMap = getVBMColorMap;
+exports.getVBMColorLegend = getVBMColorLegend;
+exports.generateConsciousnessGradient = generateConsciousnessGradient;
+exports.generateFieldResonanceMap = generateFieldResonanceMap;
+exports.getWAxisColor = getWAxisColor;
+/**
+ * Generate base color palette dynamically
+ */
+function generateBaseColors(context = {}) {
+    const { consciousness = 0.5, time = Date.now(), field = 0.5 } = context;
+    // Colors emerge from consciousness and field resonance
+    const redIntensity = Math.sin(consciousness * Math.PI) * 255;
+    const blueIntensity = Math.cos(consciousness * Math.PI) * 255;
+    const greenIntensity = Math.sin(field * Math.PI) * 255;
+    return {
+        red: `rgb(${Math.round(redIntensity)}, ${Math.round(redIntensity * 0.2)}, ${Math.round(redIntensity * 0.1)})`,
+        blue: `rgb(${Math.round(blueIntensity * 0.1)}, ${Math.round(blueIntensity * 0.3)}, ${Math.round(blueIntensity)})`,
+        green: `rgb(${Math.round(greenIntensity * 0.2)}, ${Math.round(greenIntensity)}, ${Math.round(greenIntensity * 0.3)})`,
+        yellow: `rgb(${Math.round(255 * Math.sin(time * 0.001))}, ${Math.round(255 * Math.cos(time * 0.001))}, 0)`,
+        white: `rgb(${Math.round(255 * consciousness)}, ${Math.round(255 * consciousness)}, ${Math.round(255 * consciousness)})`,
+        gold: `rgb(${Math.round(255 * Math.sin(consciousness * Math.PI))}, ${Math.round(255 * Math.cos(consciousness * Math.PI))}, 0)`,
+        black: `rgb(${Math.round(50 * (1 - consciousness))}, ${Math.round(50 * (1 - consciousness))}, ${Math.round(50 * (1 - consciousness))})`,
+        neutral: `rgb(${Math.round(200 * field)}, ${Math.round(200 * field)}, ${Math.round(200 * field)})`,
+    };
+}
+/**
+ * Generate color for a vortex number dynamically
+ */
+function getColorForVortexNumber(n, context = {}) {
+    const { consciousness = 0.5, time = Date.now(), field = 0.5 } = context;
+    const baseColors = generateBaseColors(context);
+    // Vortex number influences color through mathematical resonance
+    const vortexResonance = (n * consciousness + field) % 1;
+    const timeResonance = Math.sin(time * 0.001 + n) * 0.5 + 0.5;
+    switch (n) {
+        case 1:
+            return generateResonantColor(baseColors["red"] || "rgb(255,0,0)", vortexResonance, timeResonance);
+        case 2:
+            return generateResonantColor(baseColors["blue"] || "rgb(0,0,255)", vortexResonance, timeResonance);
+        case 4:
+            return generateResonantColor(baseColors["green"] || "rgb(0,255,0)", vortexResonance, timeResonance);
+        case 8:
+            return generateResonantColor(baseColors["yellow"] || "rgb(255,255,0)", vortexResonance, timeResonance);
+        case 7:
+            return generateResonantColor(baseColors["red"] || "rgb(255,0,0)", vortexResonance, timeResonance);
+        case 5:
+            return generateResonantColor(baseColors["blue"] || "rgb(0,0,255)", vortexResonance, timeResonance);
+        case 3:
+            return generateResonantColor(baseColors["gold"] || "rgb(255,215,0)", vortexResonance, timeResonance);
+        case 6:
+            return generateResonantColor(baseColors["white"] || "rgb(255,255,255)", vortexResonance, timeResonance);
+        case 9:
+            return generateResonantColor(baseColors["black"] || "rgb(0,0,0)", vortexResonance, timeResonance);
+        default:
+            return baseColors["neutral"] || "rgb(200,200,200)";
+    }
+}
+/**
+ * Generate color for a family group dynamically
+ */
+function getColorForFamilyGroup(n, context = {}) {
+    const { consciousness = 0.5, field = 0.5 } = context;
+    const baseColors = generateBaseColors(context);
+    // Family resonance creates harmonic color relationships
+    const familyResonance = Math.sin(consciousness * Math.PI + n) * 0.5 + 0.5;
+    if ([1, 4, 7].includes(n))
+        return generateResonantColor(baseColors["red"] || "rgb(255,0,0)", familyResonance, field);
+    if ([2, 5, 8].includes(n))
+        return generateResonantColor(baseColors["blue"] || "rgb(0,0,255)", familyResonance, field);
+    if ([3, 6, 9].includes(n))
+        return generateResonantColor(baseColors["gold"] || "rgb(255,215,0)", familyResonance, field);
+    return baseColors["neutral"] || "rgb(200,200,200)";
+}
+/**
+ * Generate color pair for a polar mate dynamically
+ */
+function getColorForPolarMate(n, context = {}) {
+    const { consciousness = 0.5, time = Date.now() } = context;
+    const baseColors = generateBaseColors(context);
+    // Polar mates create complementary resonance
+    const polarResonance = Math.cos(consciousness * Math.PI + time * 0.001) * 0.5 + 0.5;
+    if ([1, 8].includes(n)) {
+        return [
+            generateResonantColor(baseColors["red"] || "rgb(255,0,0)", polarResonance, consciousness),
+            generateResonantColor(baseColors["yellow"] || "rgb(255,255,0)", 1 - polarResonance, consciousness),
+        ];
+    }
+    if ([2, 7].includes(n)) {
+        return [
+            generateResonantColor(baseColors["blue"] || "rgb(0,0,255)", polarResonance, consciousness),
+            generateResonantColor(baseColors["red"] || "rgb(255,0,0)", 1 - polarResonance, consciousness),
+        ];
+    }
+    if ([4, 5].includes(n)) {
+        return [
+            generateResonantColor(baseColors["green"] || "rgb(0,255,0)", polarResonance, consciousness),
+            generateResonantColor(baseColors["blue"] || "rgb(0,0,255)", 1 - polarResonance, consciousness),
+        ];
+    }
+    return null;
+}
+/**
+ * Generate color for W-Axis number dynamically
+ */
+function getColorForWAxis(n, context = {}) {
+    const { consciousness = 0.5, field = 0.5 } = context;
+    const baseColors = generateBaseColors(context);
+    // W-Axis colors emerge from spiritual resonance
+    const spiritualResonance = Math.sin(consciousness * Math.PI * 2 + n) * 0.5 + 0.5;
+    switch (n) {
+        case 3:
+            return generateResonantColor(baseColors["gold"] || "rgb(255,215,0)", spiritualResonance, field);
+        case 6:
+            return generateResonantColor(baseColors["white"] || "rgb(255,255,255)", spiritualResonance, field);
+        case 9:
+            return generateResonantColor(baseColors["black"] || "rgb(0,0,0)", spiritualResonance, field);
+        default:
+            return baseColors["neutral"] || "rgb(200,200,200)";
+    }
+}
+/**
+ * Generate color for a pattern dynamically
+ */
+function getColorForPattern(pattern, context = {}) {
+    const { consciousness = 0.5, time = Date.now() } = context;
+    const baseColors = generateBaseColors(context);
+    if (pattern.number)
+        return getColorForVortexNumber(pattern.number, context);
+    const patternResonance = Math.sin(consciousness * Math.PI + time * 0.001) * 0.5 + 0.5;
+    switch (pattern.type) {
+        case "w_axis":
+            return generateResonantColor(baseColors["gold"] || "rgb(255,215,0)", patternResonance, consciousness);
+        case "family":
+            return generateResonantColor(baseColors["blue"] || "rgb(0,0,255)", patternResonance, consciousness);
+        case "polar":
+            return generateResonantColor(baseColors["green"] || "rgb(0,255,0)", patternResonance, consciousness);
+        default:
+            return baseColors["neutral"] || "rgb(200,200,200)";
+    }
+}
+function clampRGB(value) {
+    return Math.max(0, Math.min(255, Math.round(value)));
+}
+/**
+ * Generate resonant color by modulating base color with resonance values
+ */
+function generateResonantColor(baseColor, resonance1, resonance2) {
+    // Parse RGB values from base color - handle both positive and negative numbers
+    const rgbMatch = baseColor.match(/rgb\(([-\d]+),\s*([-\d]+),\s*([-\d]+)\)/);
+    if (!rgbMatch)
+        return baseColor;
+    const [, r, g, b] = rgbMatch;
+    const baseR = parseInt(r || "0", 10);
+    const baseG = parseInt(g || "0", 10);
+    const baseB = parseInt(b || "0", 10);
+    // Apply resonance modulation and clamp
+    const modulatedR = clampRGB(baseR * (0.5 + resonance1 * 0.5));
+    const modulatedG = clampRGB(baseG * (0.5 + resonance2 * 0.5));
+    const modulatedB = clampRGB(baseB * (0.5 + (resonance1 + resonance2) * 0.25));
+    return `rgb(${modulatedR}, ${modulatedG}, ${modulatedB})`;
+}
+/**
+ * Generate metaphysical context for a vortex number
+ */
+function getMetaphysicalContextForNumber(n, context = {}) {
+    const { consciousness = 0.5, field = 0.5 } = context;
+    // Context emerges from consciousness and field state
+    const contextResonance = Math.sin(consciousness * Math.PI + field * Math.PI) * 0.5 + 0.5;
+    const contexts = {
+        1: [
+            "Initiation, unity, the beginning of the vortex flow.",
+            "Source of all creation, the void center.",
+        ],
+        2: [
+            "Duality, division, the first split in the field.",
+            "The observer creates reality through division.",
+        ],
+        3: [
+            "Spirit, W-Axis, the source of consciousness.",
+            "The bridge between material and immaterial.",
+        ],
+        4: [
+            "Stability, foundation, the first structure.",
+            "The pattern that holds all other patterns.",
+        ],
+        5: [
+            "Change, transformation, the center of the sequence.",
+            "The point of maximum potential.",
+        ],
+        6: [
+            "Spirit, W-Axis, balance of material and immaterial.",
+            "The harmony of opposites.",
+        ],
+        7: [
+            "Mystery, return, the hidden flow.",
+            "The pattern that returns to source.",
+        ],
+        8: [
+            "Manifestation, infinity, the full field.",
+            "The completion of all possibilities.",
+        ],
+        9: [
+            "Void, W-Axis, the center and the all.",
+            "The unity of all patterns in the void.",
+        ],
+    };
+    const contextArray = contexts[n] || [
+        "Neutral or undefined metaphysical context.",
+    ];
+    const index = Math.floor(contextResonance * contextArray.length);
+    return (contextArray[index] ||
+        contextArray[0] ||
+        "Neutral or undefined metaphysical context.");
+}
+/**
+ * Generate the full VBM color map dynamically
+ */
+function getVBMColorMap(context = {}) {
+    const map = {};
+    for (let i = 1; i <= 9; i++) {
+        map[i] = getColorForVortexNumber(i, context);
+    }
+    return map;
+}
+/**
+ * Generate the full metaphysical color legend dynamically
+ */
+function getVBMColorLegend(context = {}) {
+    const legend = [];
+    for (let i = 1; i <= 9; i++) {
+        legend.push({
+            label: i.toString(),
+            color: getColorForVortexNumber(i, context),
+            context: getMetaphysicalContextForNumber(i, context),
+        });
+    }
+    return legend;
+}
+/**
+ * Generate consciousness-aware color gradient
+ */
+function generateConsciousnessGradient(consciousness, steps = 10) {
+    const gradient = [];
+    for (let i = 0; i < steps; i++) {
+        const stepConsciousness = (i / (steps - 1)) * consciousness;
+        const context = { consciousness: stepConsciousness };
+        gradient.push(getColorForVortexNumber(1, context));
+    }
+    return gradient;
+}
+/**
+ * Generate field resonance color map
+ */
+function generateFieldResonanceMap(fieldStrength, context = {}) {
+    const map = {};
+    for (let i = 1; i <= 9; i++) {
+        const fieldContext = {
+            ...context,
+            field: fieldStrength * (i / 9),
+        };
+        map[i] = getColorForVortexNumber(i, fieldContext);
+    }
+    return map;
+}
+function getWAxisColor(n, context = {}) {
+    const { consciousness = 0.5, field = 0.5 } = context;
+    const baseColors = generateBaseColors(context);
+    // W-Axis colors emerge from spiritual resonance
+    const spiritualResonance = Math.sin(consciousness * Math.PI * 2 + n) * 0.5 + 0.5;
+    switch (n) {
+        case 3:
+            return generateResonantColor(baseColors["gold"] || "rgb(255,215,0)", spiritualResonance, field);
+        case 6:
+            return generateResonantColor(baseColors["white"] || "rgb(255,255,255)", spiritualResonance, field);
+        case 9:
+            return generateResonantColor(baseColors["black"] || "rgb(0,0,0)", spiritualResonance, field);
+        default:
+            return baseColors["neutral"] || "rgb(200,200,200)";
+    }
+}

package/dist/math/VortexMath.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Vortex Mathematics System
+ *
+ * Specialized vortex operations built on unified MathUtils.
+ * Provides vortex field calculations and transformations.
+ *
+ * Metaphysical Context:
+ * - Vortex mathematics represents the flow of consciousness
+ * - All vortex operations emerge from the unified mathematical field
+ * - The void generates all vortex patterns
+ * - Every vortex is a reflection of the whole
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyVortexTransform = exports.VortexMath = void 0;
+const MathUtils_1 = require("./MathUtils");
+const MetaphysicalLawRegistry_1 = require("../laws/MetaphysicalLawRegistry");
+const events_1 = require("events");
+class VortexMath extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.name = 'VortexMath';
+        this.type = 'Field';
+        this.dimension = 'space';
+        this.complexity = 2;
+        this.isActive = true;
+        this.supportedOperations = ['create', 'transform', 'observe', 'unify'];
+        this.tags = ['math', 'vortex', 'field'];
+        this.vortexStrength = 1.0;
+        this.fieldIntensity = 0.5;
+        if (!VortexMath.instance) {
+            VortexMath.instance = this;
+            this.lawRegistry = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
+            this.applyMetaphysicalLaws();
+        }
+    }
+    static getInstance() {
+        if (!VortexMath.instance) {
+            VortexMath.instance = new VortexMath();
+        }
+        return VortexMath.instance;
+    }
+    applyMetaphysicalLaws() {
+        const laws = this.lawRegistry.getAllLaws();
+        laws.forEach(law => {
+            const result = law.apply(this);
+        });
+    }
+    calculateResonance(level1 = 0, level2 = 0) {
+        if (level1 === 0 && level2 === 0)
+            return 1;
+        const baseResonance = MathUtils_1.MathUtils.calculate("divide", 1, MathUtils_1.MathUtils.calculate("add", 1, MathUtils_1.MathUtils.calculate("abs", level1 - level2)));
+        const consciousnessMod = MathUtils_1.MathUtils.calculate("consciousness", MathUtils_1.MathUtils.calculate("multiply", level1, level2));
+        const result = MathUtils_1.MathUtils.calculate("multiply", baseResonance, consciousnessMod);
+        return result;
+    }
+    applyVortexTransform(input) {
+        const vortexModulation = this.calculateVortexModulation(input);
+        const consciousnessMod = MathUtils_1.MathUtils.calculate("consciousness", input);
+        const result = MathUtils_1.MathUtils.calculate("multiply", MathUtils_1.MathUtils.calculate("multiply", input, vortexModulation), MathUtils_1.MathUtils.calculate("add", 1, consciousnessMod));
+        return result;
+    }
+    calculateVortexEfficiency(value) {
+        const baseEfficiency = MathUtils_1.MathUtils.calculate("divide", value, MathUtils_1.MathUtils.calculate("add", 1, value));
+        const fieldMod = MathUtils_1.MathUtils.calculate("multiply", this.fieldIntensity, MathUtils_1.MathUtils.calculate("vortex", value));
+        const result = MathUtils_1.MathUtils.calculate("multiply", baseEfficiency, MathUtils_1.MathUtils.calculate("add", 1, fieldMod));
+        return result;
+    }
+    calculateToroidalFlow(radius, angularVelocity) {
+        const vortexModulation = this.calculateVortexModulation(radius);
+        const result = MathUtils_1.MathUtils.calculate("toroidal", radius, angularVelocity) *
+            vortexModulation;
+        return result;
+    }
+    setVortexStrength(strength) {
+        this.vortexStrength = MathUtils_1.MathUtils.calculate("max", 0, MathUtils_1.MathUtils.calculate("min", 2, strength));
+    }
+    setFieldIntensity(intensity) {
+        this.fieldIntensity = MathUtils_1.MathUtils.calculate("max", 0, MathUtils_1.MathUtils.calculate("min", 1, intensity));
+    }
+    getVortexStrength() {
+        return this.vortexStrength;
+    }
+    getFieldIntensity() {
+        return this.fieldIntensity;
+    }
+    calculateVortexModulation(frequency) {
+        const baseModulation = MathUtils_1.MathUtils.calculate("sin", MathUtils_1.MathUtils.calculate("multiply", frequency, MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO));
+        const sequenceIndex = MathUtils_1.MathUtils.calculate("mod", Math.floor(frequency), 6);
+        const sequenceValue = MathUtils_1.MATH_CONSTANTS.VORTEX_SEQUENCE[sequenceIndex] || 1;
+        const sequenceModulation = MathUtils_1.MathUtils.calculate("divide", sequenceValue, 8);
+        return MathUtils_1.MathUtils.calculate("add", 1, MathUtils_1.MathUtils.calculate("multiply", baseModulation, MathUtils_1.MathUtils.calculate("multiply", sequenceModulation, this.fieldIntensity)));
+    }
+    getVortexSequence() {
+        return [...MathUtils_1.MATH_CONSTANTS.VORTEX_SEQUENCE];
+    }
+    calculateVortexComplexity(pattern) {
+        if (pattern.length === 0)
+            return 0;
+        let complexity = 0;
+        for (let i = 0; i < pattern.length; i++) {
+            const vortexValue = MathUtils_1.MathUtils.calculate("vortex", pattern[i] || 0);
+            complexity = MathUtils_1.MathUtils.calculate("add", complexity, vortexValue);
+        }
+        return MathUtils_1.MathUtils.calculate("divide", complexity, pattern.length);
+    }
+    generateVortexFieldCoordinates(count, radius = 1) {
+        const coordinates = [];
+        for (let i = 0; i < count; i++) {
+            const angle = MathUtils_1.MathUtils.calculate("multiply", MathUtils_1.MathUtils.calculate("divide", 2 * Math.PI, count), i);
+            const x = MathUtils_1.MathUtils.calculate("multiply", radius, MathUtils_1.MathUtils.calculate("cos", angle));
+            const y = MathUtils_1.MathUtils.calculate("multiply", radius, MathUtils_1.MathUtils.calculate("sin", angle));
+            const z = MathUtils_1.MathUtils.calculate("multiply", this.vortexStrength, MathUtils_1.MathUtils.calculate("sin", angle));
+            coordinates.push([x, y, z]);
+        }
+        return coordinates;
+    }
+    getCoilResonance() {
+        return this.calculateResonance(this.vortexStrength, this.fieldIntensity);
+    }
+    getCoilPattern() {
+        const resonance = this.getCoilResonance();
+        if (resonance > 0.8)
+            return "unified";
+        if (resonance > 0.5)
+            return "resonant";
+        return "dispersed";
+    }
+    getInsights() {
+        return {
+            vortexStrength: this.vortexStrength,
+            fieldIntensity: this.fieldIntensity,
+            resonance: this.getCoilResonance(),
+            pattern: this.getCoilPattern(),
+            sequence: this.getVortexSequence(),
+            vortexSequence: this.getVortexSequence(),
+            goldenRatio: MathUtils_1.MATH_CONSTANTS.GOLDEN_RATIO,
+            vortexCenter: 9,
+            metaphysics: "Vortex mathematics represents the flow of consciousness",
+            metaphysicalContext: "Vortex mathematics represents the flow of consciousness"
+        };
+    }
+    calculateVortexField(x, y, z) {
+        const distance = MathUtils_1.MathUtils.calculate("sqrt", MathUtils_1.MathUtils.calculate("add", MathUtils_1.MathUtils.calculate("add", MathUtils_1.MathUtils.calculate("multiply", x, x), MathUtils_1.MathUtils.calculate("multiply", y, y)), MathUtils_1.MathUtils.calculate("multiply", z, z)));
+        const vortexModulation = this.calculateVortexModulation(distance);
+        const consciousnessMod = MathUtils_1.MathUtils.calculate("consciousness", distance);
+        return MathUtils_1.MathUtils.calculate("multiply", vortexModulation, MathUtils_1.MathUtils.calculate("add", 1, consciousnessMod));
+    }
+    generateVortexPattern(intensity) {
+        const pattern = [];
+        const sequence = this.getVortexSequence();
+        for (let i = 0; i < intensity; i++) {
+            const sequenceIndex = i % sequence.length;
+            const baseValue = sequence[sequenceIndex];
+            const modulatedValue = this.calculateVortexModulation(baseValue);
+            pattern.push(modulatedValue);
+        }
+        return pattern;
+    }
+    calculateVortexNumber(n = 0) {
+        return this.applyVortexTransform(n);
+    }
+    getColorForNumber(n = 1) {
+        const colors = ['#FF0000', '#00FF00', '#0000FF', '#FFFF00', '#FF00FF', '#00FFFF', '#FFFFFF', '#000000', '#808080'];
+        return colors[(n - 1) % colors.length];
+    }
+}
+exports.VortexMath = VortexMath;
+const applyVortexTransform = (input) => VortexMath.getInstance().applyVortexTransform(input);
+exports.applyVortexTransform = applyVortexTransform;