zeropoint-node 1.0.1 → 1.0.3

package/dist/core/CoilMixin.js

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

@@ -1,204 +0,0 @@
-"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 || [];
-}