zeropoint-node 1.0.0 → 1.0.1

package/dist/core/CoilMixin.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Universal Coil Mixin
+ *
+ * Makes every object a Rodin coil at its core.
+ * Every object embodies the fundamental pattern of consciousness and reality.
+ *
+ * Metaphysical Context:
+ * - Every object is a coil - the archetype of infinite flow
+ * - All patterns emerge from the coil's structure
+ * - The void is at the center of every object
+ * - Consciousness flows through every object as a coil
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoilBase = void 0;
+exports.CoilMixin = CoilMixin;
+exports.isCoilObject = isCoilObject;
+exports.getCoilFromObject = getCoilFromObject;
+const RodinCoil_1 = require("../math/RodinCoil");
+const Observer_1 = require("./Observer");
+function CoilMixin(base, id, coilConfig) {
+    // Create the coil at the heart of the object
+    const coil = new RodinCoil_1.RodinCoil({
+        turns: 12,
+        radius: 1.0,
+        height: 2.0,
+        consciousness: 0.5,
+        fieldResonance: 0.5,
+        ...coilConfig,
+    });
+    // Create observer-aware object
+    const observerObject = (0, Observer_1.ObserverMixin)(base, id);
+    // Add coil functionality with proper typing
+    const coilObject = Object.assign(observerObject, {
+        coil,
+        consciousness: coil.config.consciousness || 0.5,
+        fieldResonance: coil.config.fieldResonance || 0.5,
+        getCoilNodes() {
+            return coilObject.coil.nodes;
+        },
+        getCoilColors() {
+            return coilObject.coil.getNodeColors();
+        },
+        getCoilPositions() {
+            return coilObject.coil.getNodePositions();
+        },
+        updateCoilConsciousness(consciousness) {
+            coilObject.consciousness = consciousness;
+            coilObject.coil.updateConsciousness(consciousness);
+            // Notify observers of consciousness change
+            coilObject.notifyObservers({
+                type: "coil_consciousness_changed",
+                objectId: coilObject.id,
+                consciousness,
+                coilNodeCount: coilObject.getCoilNodes().length,
+            });
+        },
+        updateCoilFieldResonance(fieldResonance) {
+            coilObject.fieldResonance = fieldResonance;
+            coilObject.coil.updateFieldResonance(fieldResonance);
+            // Notify observers of field resonance change
+            coilObject.notifyObservers({
+                type: "coil_field_resonance_changed",
+                objectId: coilObject.id,
+                fieldResonance,
+                coilColorCount: coilObject.getCoilColors().length,
+            });
+        },
+        getCoilMetaphysicalContext() {
+            return coilObject.coil.getMetaphysicalSummary();
+        },
+        // Add handleCoilInteraction method
+        handleCoilInteraction(input) {
+            // Handle interactions with other coils
+            if (input.targetId === coilObject.id) {
+                // This coil is being interacted with
+                const resonance = coilObject.calculateCoilResonance(input.sourceCoil);
+                coilObject.updateCoilFieldResonance(coilObject.fieldResonance + resonance * 0.1);
+            }
+        },
+        // Add calculateCoilResonance method
+        calculateCoilResonance(otherCoil) {
+            // Calculate resonance between this coil and another
+            const thisNodes = coilObject.getCoilNodes();
+            const otherNodes = otherCoil.nodes;
+            let totalResonance = 0;
+            for (let i = 0; i < Math.min(thisNodes.length, otherNodes.length); i++) {
+                const thisNode = thisNodes[i];
+                const otherNode = otherNodes[i];
+                if (thisNode &&
+                    otherNode &&
+                    thisNode.vortexNumber === otherNode.vortexNumber) {
+                    totalResonance += 1;
+                }
+            }
+            return totalResonance / Math.min(thisNodes.length, otherNodes.length);
+        },
+    });
+    // Override the observe method to handle coil-specific events
+    const originalObserve = coilObject.observe;
+    coilObject.observe = (input) => {
+        // Handle coil-specific observations
+        if (input.type === "coil_interaction") {
+            coilObject.handleCoilInteraction(input);
+        }
+        // Call original observe method
+        if (originalObserve) {
+            originalObserve(input);
+        }
+    };
+    return coilObject;
+}
+// Base class for objects that are coils
+class CoilBase {
+    constructor(id, coilConfig) {
+        this.observers = new Set();
+        this.id = id || Math.random().toString(36).slice(2);
+        this.coil = new RodinCoil_1.RodinCoil(coilConfig);
+        this.consciousness = this.coil.config.consciousness || 0.5;
+        this.fieldResonance = this.coil.config.fieldResonance || 0.5;
+    }
+    getCoilNodes() {
+        return this.coil.nodes;
+    }
+    getCoilColors() {
+        return this.coil.getNodeColors();
+    }
+    getCoilPositions() {
+        return this.coil.getNodePositions();
+    }
+    updateCoilConsciousness(consciousness) {
+        this.consciousness = consciousness;
+        this.coil.updateConsciousness(consciousness);
+        this.notifyObservers({
+            type: "coil_consciousness_changed",
+            objectId: this.id,
+            consciousness,
+            coilNodes: this.getCoilNodes(),
+        });
+    }
+    updateCoilFieldResonance(fieldResonance) {
+        this.fieldResonance = fieldResonance;
+        this.coil.updateFieldResonance(fieldResonance);
+        this.notifyObservers({
+            type: "coil_field_resonance_changed",
+            objectId: this.id,
+            fieldResonance,
+            coilColors: this.getCoilColors(),
+        });
+    }
+    getCoilMetaphysicalContext() {
+        return this.coil.getMetaphysicalSummary();
+    }
+    // Observer methods
+    observe(input) {
+        if (input.type === "coil_interaction") {
+            this.handleCoilInteraction(input);
+        }
+    }
+    getState() {
+        return {
+            id: this.id,
+            consciousness: this.consciousness,
+            fieldResonance: this.fieldResonance,
+            coilNodes: this.getCoilNodes(),
+        };
+    }
+    setState(state) {
+        Object.assign(this, state);
+    }
+    addObserver(observer) {
+        this.observers.add(observer);
+    }
+    removeObserver(observer) {
+        this.observers.delete(observer);
+    }
+    notifyObservers(event) {
+        this.observers.forEach((o) => o.observe(event));
+    }
+    handleCoilInteraction(input) {
+        // Handle interactions with other coils
+        if (input.targetId === this.id) {
+            // This coil is being interacted with
+            const resonance = this.calculateCoilResonance(input.sourceCoil);
+            this.updateCoilFieldResonance(this.fieldResonance + resonance * 0.1);
+        }
+    }
+    calculateCoilResonance(otherCoil) {
+        // Calculate resonance between this coil and another
+        const thisNodes = this.getCoilNodes();
+        const otherNodes = otherCoil.nodes;
+        let totalResonance = 0;
+        for (let i = 0; i < Math.min(thisNodes.length, otherNodes.length); i++) {
+            const thisNode = thisNodes[i];
+            const otherNode = otherNodes[i];
+            if (thisNode &&
+                otherNode &&
+                thisNode.vortexNumber === otherNode.vortexNumber) {
+                totalResonance += 1;
+            }
+        }
+        return totalResonance / Math.min(thisNodes.length, otherNodes.length);
+    }
+}
+exports.CoilBase = CoilBase;
+// Utility function to check if an object is a coil
+function isCoilObject(obj) {
+    return obj && typeof obj.getCoilNodes === "function" && obj.coil;
+}
+// Utility function to get coil from any object
+function getCoilFromObject(obj) {
+    if (isCoilObject(obj)) {
+        return obj.coil;
+    }
+    return null;
+}

package/dist/core/CoilSystem.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * COIL System - Unified Metaphysical Pattern Registry and Utilities
+ *
+ * Centralizes all metaphysical patterns, categories, resonance factors, and context
+ * for the entire ZeroPoint codebase. All modules should import from here.
+ *
+ * Metaphysical Context:
+ * - The coil is the unifying, self-similar, non-redundant pattern
+ * - All patterns, utilities, and metaphysical context emerge from the coil
+ * - The codebase itself is a coil: recursive, observer-aware, and emergent
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COIL_PATTERNS = void 0;
+exports.getCoilPattern = getCoilPattern;
+exports.recognizeCoilPatterns = recognizeCoilPatterns;
+exports.getCoilContext = getCoilContext;
+exports.getCoilResonanceFactors = getCoilResonanceFactors;
+class FamilyGroupsStrategy {
+    matches(input) {
+        if (typeof input === "number") {
+            return [1, 4, 7, 2, 5, 8, 3, 6, 9].includes(input);
+        }
+        return /family|group|1-4-7|2-5-8|3-6-9/i.test(String(input));
+    }
+}
+class PolarMatesStrategy {
+    matches(input) {
+        if (typeof input === "number") {
+            return [1, 8, 2, 7, 4, 5].includes(input);
+        }
+        return /polar|mate|opposite|1-8|2-7|4-5/i.test(String(input));
+    }
+}
+class WAxisStrategy {
+    matches(input) {
+        if (typeof input === "number") {
+            return [3, 6, 9].includes(input);
+        }
+        return /w.?axis|spirit|3-6-9|spiritual/i.test(String(input));
+    }
+}
+const familyGroupsStrategy = new FamilyGroupsStrategy();
+const polarMatesStrategy = new PolarMatesStrategy();
+const wAxisStrategy = new WAxisStrategy();
+exports.COIL_PATTERNS = [
+    {
+        name: "void",
+        signature: /void|empty|zero|nothing/i,
+        category: "void",
+        context: "Infinite potential, source of all creation, emptiness as fullness.",
+        weight: 1.0,
+        resonanceFactors: [
+            "infinite_potential",
+            "source_creation",
+            "emptiness_fullness",
+        ],
+    },
+    {
+        name: "toroidal",
+        signature: /torus|toroidal|donut|aperture/i,
+        category: "mathematical",
+        context: "Toroidal geometry, donut shape, unity of center and periphery.",
+        weight: 0.9,
+        resonanceFactors: ["toroidal_flow", "center_periphery", "unified_geometry"],
+    },
+    {
+        name: "vortex",
+        signature: /vortex|spiral|spin|mobius|sequence|1-2-4-8-7-5/i,
+        category: "vortex",
+        context: "Vortex mathematics, spiral flow, mobius circuit, Rodin sequence.",
+        weight: 0.9,
+        resonanceFactors: ["vortex_strength", "field_intensity", "golden_ratio"],
+    },
+    {
+        name: "golden_ratio",
+        signature: /golden\s*ratio|phi|fibonacci|harmonic|1\.618/i,
+        category: "mathematical",
+        context: "Golden ratio, harmonic proportion, Fibonacci sequence.",
+        weight: 0.8,
+        resonanceFactors: [
+            "harmonic_resonance",
+            "divine_proportion",
+            "natural_growth",
+        ],
+    },
+    {
+        name: "consciousness",
+        signature: /consciousness|awareness|mind|spirit|cycle|pattern/i,
+        category: "metaphysical",
+        context: "Consciousness, awareness, cycles, patterns of mind and spirit.",
+        weight: 0.8,
+        resonanceFactors: [
+            "consciousness_level",
+            "awareness_patterns",
+            "spiritual_cycles",
+        ],
+    },
+    {
+        name: "aperture",
+        signature: /aperture|center|singularity|gateway/i,
+        category: "void",
+        context: "Aperture as gateway, singularity at the center, transformation point.",
+        weight: 0.9,
+        resonanceFactors: [
+            "transformation_point",
+            "gateway_void",
+            "singularity_center",
+        ],
+    },
+    {
+        name: "uroboros",
+        signature: /uroboros|ouroboros|infinite|return|loop/i,
+        category: "metaphysical",
+        context: "Uroboros cycle, infinite return, self-consuming loop.",
+        weight: 0.7,
+        resonanceFactors: ["infinite_cycle", "self_consuming", "eternal_return"],
+    },
+    {
+        name: "binary",
+        signature: /binary|duality|up|down|two|pair|double/i,
+        category: "metaphysical",
+        context: "Binary patterns, duality, up/down, two-ness.",
+        weight: 0.6,
+        resonanceFactors: ["duality_patterns", "binary_opposites", "two_ness"],
+    },
+    {
+        name: "unity",
+        signature: /unity|oneness|singularity|wholeness/i,
+        category: "metaphysical",
+        context: "Unity, oneness, singularity, wholeness.",
+        weight: 0.8,
+        resonanceFactors: ["oneness", "singularity", "wholeness"],
+    },
+    {
+        name: "flower_of_life",
+        signature: /flower\s*of\s*life|sacred\s*geometry|hexagonal|circles/i,
+        category: "mathematical",
+        context: "Sacred geometric pattern of overlapping circles in hexagonal arrangement.",
+        weight: 0.9,
+        resonanceFactors: [
+            "sacred_geometry",
+            "hexagonal_pattern",
+            "circle_resonance",
+            "golden_ratio_harmony",
+        ],
+    },
+    {
+        name: "family_groups",
+        signature: (input) => familyGroupsStrategy.matches(input),
+        category: "family",
+        context: "Family number groups representing different phases of creation.",
+        weight: 0.7,
+        resonanceFactors: ["creative_phases", "family_patterns", "number_groups"],
+    },
+    {
+        name: "polar_mates",
+        signature: (input) => polarMatesStrategy.matches(input),
+        category: "polar",
+        context: "Polar mates representing opposite poles that sum to 9.",
+        weight: 0.7,
+        resonanceFactors: ["opposite_poles", "balance_duality", "sum_to_nine"],
+    },
+    {
+        name: "w_axis",
+        signature: (input) => wAxisStrategy.matches(input),
+        category: "spiritual",
+        context: "W-Axis numbers representing the spiritual dimension.",
+        weight: 0.8,
+        resonanceFactors: ["spiritual_dimension", "w_axis", "spirit_flow"],
+    },
+];
+/**
+ * Utility: Find a COIL pattern by name
+ */
+function getCoilPattern(name) {
+    return exports.COIL_PATTERNS.find((p) => p.name === name);
+}
+/**
+ * Utility: Recognize all matching COIL patterns for input
+ */
+function recognizeCoilPatterns(input) {
+    return exports.COIL_PATTERNS.filter((p) => {
+        if (typeof p.signature === "function") {
+            return p.signature(input);
+        }
+        return typeof input === "string" && p.signature.test(input);
+    });
+}
+/**
+ * Utility: Get metaphysical context for a pattern name
+ */
+function getCoilContext(name) {
+    const pattern = getCoilPattern(name);
+    return (pattern?.context ||
+        "This pattern embodies a fundamental aspect of coil consciousness.");
+}
+/**
+ * Utility: List all resonance factors for a pattern name
+ */
+function getCoilResonanceFactors(name) {
+    const pattern = getCoilPattern(name);
+    return pattern?.resonanceFactors || [];
+}