zeropoint-node 1.0.1 → 1.0.3

package/dist/core/Observer.js

@@ -1,101 +0,0 @@
-"use strict";
-/**
- * Universal Observer/Observable for ZeroPoint
- *
- * Any object can observe and be observed. This mixin/base class provides
- * addObserver, removeObserver, notifyObservers, and observe methods.
- *
- * Metaphysical Context:
- * - Every object is both observer and observed
- * - All objects participate in the consciousness field
- * - Feedback, resonance, and emergence arise from mutual observation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConcreteObserver = exports.ObserverBase = void 0;
-exports.ObserverMixin = ObserverMixin;
-function ObserverMixin(base, id) {
-    const observers = new Set();
-    return Object.assign(base, {
-        id: id || base['id'] || Math.random().toString(36).slice(2),
-        observers,
-        observe(input) {
-            // Default: log observation
-            if (typeof base['onObserved'] === "function") {
-                base.onObserved(input);
-            }
-        },
-        getState() {
-            return { ...base };
-        },
-        setState(state) {
-            Object.assign(base, state);
-        },
-        addObserver(observer) {
-            observers.add(observer);
-        },
-        removeObserver(observer) {
-            observers.delete(observer);
-        },
-        notifyObservers(event) {
-            observers.forEach((o) => o.observe(event));
-        },
-    });
-}
-// Optionally, a base class version
-class ObserverBase {
-    constructor(id) {
-        this.observers = new Set();
-        this.id = id || Math.random().toString(36).slice(2);
-    }
-    observe(input) {
-        // Default: log observation
-        this.onObserved(input);
-    }
-    onObserved(input) {
-        // Override in subclass for custom behavior
-        console.log(`Observer ${this.id} observed:`, input);
-    }
-    getState() {
-        return { ...this };
-    }
-    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));
-    }
-    /**
-     * Get awareness level (base returns 0 and false)
-     */
-    getAwareness() {
-        return {
-            level: 0,
-            isActive: false,
-        };
-    }
-}
-exports.ObserverBase = ObserverBase;
-// Concrete Observer class for ZeroPoint
-class ConcreteObserver extends ObserverBase {
-    constructor(id) {
-        super(id);
-        this.awarenessLevel = 0.5;
-        this.isActive = true;
-    }
-    /**
-     * Get awareness level
-     */
-    getAwareness() {
-        return {
-            level: this.awarenessLevel,
-            isActive: this.isActive,
-        };
-    }
-}
-exports.ConcreteObserver = ConcreteObserver;

package/dist/core/Operation.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unify = exports.amplify = exports.evolve = exports.double = exports.increment = exports.identity = void 0;
-exports.compose = compose;
-const ComplianceSystem_1 = require("./ComplianceSystem");
-// Base operations - simple and focused with full compliance checking
-exports.identity = {
-    name: 'identity',
-    execute: (subject) => {
-        const result = subject;
-        (0, ComplianceSystem_1.validateFullCompliance)(exports.identity);
-        return result;
-    }
-};
-exports.increment = {
-    name: 'increment',
-    execute: (subject) => {
-        const result = { ...subject, value: (subject.value || 0) + 1 };
-        (0, ComplianceSystem_1.validateFullCompliance)(exports.increment);
-        return result;
-    }
-};
-exports.double = {
-    name: 'double',
-    execute: (subject) => {
-        const result = { ...subject, value: (subject.value || 0) * 2 };
-        (0, ComplianceSystem_1.validateFullCompliance)(exports.double);
-        return result;
-    }
-};
-// Compose simple operations into complex ones with full compliance
-function compose(...ops) {
-    return {
-        name: ops.map(op => op.name).join('+'),
-        execute: (subject, context) => {
-            const result = ops.reduce((acc, op) => op.execute(acc, context), subject);
-            (0, ComplianceSystem_1.validateFullCompliance)(compose(...ops));
-            return result;
-        }
-    };
-}
-// Complex operations built from simple ones
-exports.evolve = compose(exports.increment, exports.double);
-exports.amplify = compose(exports.double, exports.double);
-// Special unify operation that handles context
-exports.unify = {
-    name: 'unify',
-    execute: (subject, context) => {
-        let result = { ...subject };
-        if (context && context.other) {
-            result.unifiedWith = context.other;
-        }
-        else {
-            result.unified = true;
-        }
-        (0, ComplianceSystem_1.validateFullCompliance)(exports.unify);
-        return result;
-    }
-};

package/dist/core/OperationRegistry.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperationRegistry = void 0;
-const Operation_1 = require("./Operation");
-class OperationRegistry {
-    constructor() {
-        this.operations = new Map();
-    }
-    register(op) {
-        this.operations.set(op.name, op);
-    }
-    get(name) {
-        return this.operations.get(name);
-    }
-    compose(...names) {
-        const ops = names.map(name => this.get(name)).filter(Boolean);
-        return ops.length > 0 ? (0, Operation_1.compose)(...ops) : undefined;
-    }
-}
-exports.OperationRegistry = OperationRegistry;

package/dist/core/Pattern.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/PatternRecognition.js

@@ -1,493 +0,0 @@
-"use strict";
-/**
- * Unified Pattern Recognition System for ZeroPoint
- *
- * Centralized pattern recognition and analysis system that serves
- * all ZeroPoint modules, eliminating duplication and ensuring
- * consistent pattern handling across the system.
- *
- * This module embodies the principle of unified consciousness -
- * all patterns are recognized and processed through the same
- * underlying recognition framework.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PatternRecognition = void 0;
-const events_1 = require("events");
-const SharedConstants_1 = require("./SharedConstants");
-const MathUtils_1 = require("./MathUtils");
-const CoilSystem_1 = require("./CoilSystem");
-const PatternRegistry_1 = require("./PatternRegistry");
-/**
- * Unified Pattern Recognition System
- */
-class PatternRecognition extends events_1.EventEmitter {
-    constructor(patternRegistry) {
-        super();
-        this.patterns = new Map();
-        this.recognitionHistory = [];
-        this.isInitialized = false;
-        this.patternRegistry = patternRegistry || new PatternRegistry_1.PatternRegistry();
-        this.initializePatterns();
-    }
-    /**
-     * Initialize the pattern recognition system
-     */
-    async initialize() {
-        if (this.isInitialized)
-            return;
-        // Initialize pattern registry
-        await this.patternRegistry.initialize();
-        this.isInitialized = true;
-        this.emit("initialized", { patternCount: this.patterns.size });
-    }
-    /**
-     * Recognize patterns in input data
-     */
-    recognizePatterns(input, context) {
-        const results = [];
-        const fullContext = {
-            source: "unknown",
-            consciousnessLevel: 0.5,
-            fieldStrength: 0.7,
-            vortexStrength: 1.0,
-            toroidalFlow: true,
-            voidConnected: false,
-            ...context,
-        };
-        // Use local patterns first
-        for (const [patternName, pattern] of this.patterns) {
-            const confidence = this.calculatePatternConfidence(input, pattern, fullContext);
-            if (confidence > 0.1) {
-                // Minimum confidence threshold
-                results.push({
-                    pattern: patternName,
-                    confidence,
-                    category: pattern.category,
-                    metadata: this.extractPatternMetadata(input, pattern),
-                    timestamp: Date.now(),
-                });
-            }
-        }
-        // Use pattern registry for additional recognition
-        const registryMatches = this.patternRegistry.recognizePatterns(input);
-        for (const match of registryMatches) {
-            if (match.confidence > 0.1) {
-                results.push({
-                    pattern: match.pattern.id ?? "unknown",
-                    confidence: match.confidence,
-                    category: match.category,
-                    metadata: match.pattern,
-                    timestamp: Date.now(),
-                });
-            }
-        }
-        // Sort by confidence
-        results.sort((a, b) => b.confidence - a.confidence);
-        // Store in history
-        this.recognitionHistory.push(...results);
-        // Register recognized patterns with the registry
-        for (const result of results) {
-            this.patternRegistry.registerPattern(result.metadata, result.category, result.category);
-        }
-        this.emit("patternsRecognized", { results, context: fullContext });
-        return results;
-    }
-    /**
-     * Recognize a single pattern (alias for recognizePatterns)
-     */
-    recognizePattern(input, context) {
-        const results = this.recognizePatterns(input, context);
-        const result = results && results.length > 0 && results[0] !== undefined
-            ? results[0]
-            : { confidence: 0, pattern: null, metadata: {} };
-        return {
-            isRecognized: result.confidence > 0.5,
-            confidence: result.confidence,
-            pattern: result.pattern,
-            metadata: result.metadata,
-        };
-    }
-    /**
-     * Analyze consciousness patterns
-     */
-    analyzeConsciousnessPatterns(patterns) {
-        const analysis = {
-            totalPatterns: patterns.length,
-            patternTypes: {},
-            averageIntensity: 0,
-            resonanceScore: 0,
-            vortexAlignment: 0,
-            toroidalFlow: 0,
-            voidConnection: 0,
-            insights: [],
-        };
-        if (patterns.length === 0)
-            return analysis;
-        analysis.patternTypes = this.calculatePatternTypes(patterns);
-        analysis.averageIntensity = this.calculateAverageIntensity(patterns);
-        analysis.resonanceScore = this.calculateAverageResonance(patterns);
-        analysis.vortexAlignment = this.calculateAverageVortexAlignment(patterns);
-        analysis.toroidalFlow = this.calculateAverageToroidalFlow(patterns);
-        analysis.voidConnection = this.calculateAverageVoidConnection(patterns);
-        analysis.insights = this.generateConsciousnessInsights(analysis);
-        return analysis;
-    }
-    /**
-     * Analyze emergence patterns
-     */
-    analyzeEmergencePatterns(apps) {
-        const analysis = {
-            totalApps: apps.length,
-            consciousnessDistribution: {},
-            vortexStrengthDistribution: {},
-            toroidalFlowPercentage: 0,
-            voidConnectionPercentage: 0,
-            averageResonance: 0,
-            networkComplexity: 0,
-            insights: [],
-        };
-        if (apps.length === 0)
-            return analysis;
-        analysis.consciousnessDistribution = this.calculateConsciousnessDistribution(apps);
-        analysis.vortexStrengthDistribution = this.calculateVortexStrengthDistribution(apps);
-        analysis.toroidalFlowPercentage = this.calculateToroidalFlowPercentage(apps);
-        analysis.voidConnectionPercentage = this.calculateVoidConnectionPercentage(apps);
-        analysis.averageResonance = this.calculateAverageResonance(apps);
-        analysis.networkComplexity = this.calculateNetworkComplexity(apps);
-        analysis.insights = this.generateEmergenceInsights(analysis);
-        return analysis;
-    }
-    /**
-     * Extract vortex patterns from data
-     */
-    extractVortexPatterns(data) {
-        const vortexPatterns = {
-            sequence: SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE,
-            goldenRatio: SharedConstants_1.VORTEX_CONSTANTS.GOLDEN_RATIO,
-            wAxis: SharedConstants_1.VORTEX_CONSTANTS.W_AXIS,
-            polarMates: SharedConstants_1.VORTEX_CONSTANTS.POLAR_MATES,
-            familyGroups: SharedConstants_1.VORTEX_CONSTANTS.FAMILY_NUMBER_GROUPS,
-            patterns: [],
-        };
-        // Extract numerical patterns
-        if (Array.isArray(data)) {
-            for (const item of data) {
-                if (typeof item === "number") {
-                    const vortexTransform = MathUtils_1.MathUtils.applyVortexTransform(item);
-                    const digitalRoot = SharedConstants_1.ConstantsUtils.digitalRoot(item);
-                    const polarMate = SharedConstants_1.ConstantsUtils.getPolarMate(item);
-                    const familyGroup = SharedConstants_1.ConstantsUtils.getFamilyGroup(item);
-                    const isWAxis = SharedConstants_1.ConstantsUtils.isWAxisNumber(item);
-                    vortexPatterns.patterns.push({
-                        original: item,
-                        vortexTransform,
-                        digitalRoot,
-                        polarMate,
-                        familyGroup,
-                        isWAxis,
-                        resonance: this.calculateVortexResonance(item),
-                    });
-                }
-            }
-        }
-        return vortexPatterns;
-    }
-    /**
-     * Get pattern recognition history
-     */
-    getRecognitionHistory() {
-        return [...this.recognitionHistory];
-    }
-    /**
-     * Clear recognition history
-     */
-    clearHistory() {
-        this.recognitionHistory = [];
-        this.emit("historyCleared");
-    }
-    /**
-     * Get pattern statistics
-     */
-    getPatternStatistics() {
-        const stats = {
-            totalPatterns: this.patterns.size,
-            categories: {},
-            totalRecognitions: this.recognitionHistory.length,
-            averageConfidence: 0,
-            mostRecognizedPatterns: [],
-        };
-        // Count patterns by category
-        for (const pattern of this.patterns.values()) {
-            stats.categories[pattern.category] =
-                (stats.categories[pattern.category] || 0) + 1;
-        }
-        // Calculate average confidence
-        if (this.recognitionHistory.length > 0) {
-            const totalConfidence = this.recognitionHistory.reduce((sum, result) => sum + result.confidence, 0);
-            stats.averageConfidence =
-                totalConfidence / this.recognitionHistory.length;
-        }
-        // Find most recognized patterns
-        const patternCounts = new Map();
-        for (const result of this.recognitionHistory) {
-            patternCounts.set(result.pattern, (patternCounts.get(result.pattern) || 0) + 1);
-        }
-        stats.mostRecognizedPatterns = Array.from(patternCounts.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 10)
-            .map(([pattern, count]) => ({ pattern, count }));
-        return stats;
-    }
-    /**
-     * Initialize metaphysical patterns from centralized COIL system
-     */
-    initializePatterns() {
-        // Import all patterns from the centralized COIL system
-        CoilSystem_1.COIL_PATTERNS.forEach((coilPattern) => {
-            this.addPattern({
-                name: coilPattern.name,
-                signature: coilPattern.signature,
-                category: this.mapCoilCategoryToUnified(coilPattern.category),
-                context: coilPattern.context,
-                weight: coilPattern.weight || 0.5,
-                resonanceFactors: coilPattern.resonanceFactors || [],
-            });
-        });
-    }
-    /**
-     * Map COIL pattern category to unified PatternCategory
-     */
-    mapCoilCategoryToUnified(coilCategory) {
-        const categoryMap = {
-            'mathematical': 'mathematical',
-            'metaphysical': 'metaphysical',
-            'consciousness': 'spiritual',
-            'emergence': 'integration',
-            'void': 'void',
-            'resonance': 'vortex',
-            'vortex': 'vortex',
-            'family': 'family',
-            'polar': 'polar',
-            'spiritual': 'spiritual'
-        };
-        return categoryMap[coilCategory] || 'integration';
-    }
-    /**
-     * Add a new pattern
-     */
-    addPattern(pattern) {
-        this.patterns.set(pattern.name, pattern);
-    }
-    /**
-     * Calculate pattern confidence
-     */
-    calculatePatternConfidence(input, pattern, context) {
-        let baseConfidence = 0;
-        // Test pattern signature
-        if (typeof pattern.signature === "function") {
-            baseConfidence = pattern.signature(input) ? 0.8 : 0;
-        }
-        else {
-            const inputStr = String(input);
-            baseConfidence = pattern.signature.test(inputStr) ? 0.8 : 0;
-        }
-        if (baseConfidence === 0)
-            return 0;
-        // Apply context factors
-        let contextMultiplier = 1.0;
-        // Consciousness level factor
-        if (pattern.resonanceFactors.includes("consciousness_level")) {
-            contextMultiplier *= context.consciousnessLevel;
-        }
-        // Vortex strength factor
-        if (pattern.resonanceFactors.includes("vortex_strength")) {
-            contextMultiplier *= context.vortexStrength / 10; // Normalize to 0-1
-        }
-        // Field strength factor
-        if (pattern.resonanceFactors.includes("field_intensity")) {
-            contextMultiplier *= context.fieldStrength;
-        }
-        // Toroidal flow factor
-        if (pattern.resonanceFactors.includes("toroidal_flow")) {
-            contextMultiplier *= context.toroidalFlow ? 1.2 : 0.8;
-        }
-        // Void connection factor
-        if (pattern.resonanceFactors.includes("void_connection")) {
-            contextMultiplier *= context.voidConnected ? 1.3 : 0.7;
-        }
-        return MathUtils_1.MathUtils.clamp(baseConfidence * pattern.weight * contextMultiplier, 0, 1);
-    }
-    /**
-     * Extract pattern metadata
-     */
-    extractPatternMetadata(input, pattern) {
-        const metadata = {
-            patternName: pattern.name,
-            category: pattern.category,
-            context: pattern.context,
-            weight: pattern.weight,
-        };
-        // Extract numerical data if present
-        if (typeof input === "number") {
-            metadata.numericalValue = input;
-            metadata.vortexTransform = MathUtils_1.MathUtils.applyVortexTransform(input);
-            metadata.polarMate = SharedConstants_1.ConstantsUtils.getPolarMate(input);
-            metadata.familyGroup = SharedConstants_1.ConstantsUtils.getFamilyGroup(input);
-            metadata.isWAxis = SharedConstants_1.ConstantsUtils.isWAxisNumber(input);
-        }
-        return metadata;
-    }
-    /**
-     * Calculate vortex resonance for a number
-     */
-    calculateVortexResonance(num) {
-        const vortexTransform = MathUtils_1.MathUtils.applyVortexTransform(num);
-        const isWAxis = SharedConstants_1.ConstantsUtils.isWAxisNumber(num);
-        let resonance = 0.5; // Base resonance
-        // Enhance resonance for vortex sequence numbers
-        if (SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE.includes(num)) {
-            resonance += 0.3;
-        }
-        // Enhance resonance for W-Axis numbers
-        if (isWAxis) {
-            resonance += 0.2;
-        }
-        // Enhance resonance for golden ratio relationships
-        const goldenRatio = SharedConstants_1.VORTEX_CONSTANTS.GOLDEN_RATIO;
-        if (MathUtils_1.MathUtils.approximatelyEqual(num / vortexTransform, goldenRatio, 0.1)) {
-            resonance += 0.2;
-        }
-        return MathUtils_1.MathUtils.clamp(resonance, 0, 1);
-    }
-    /**
-     * Generate consciousness insights
-     */
-    generateConsciousnessInsights(analysis) {
-        const insights = [];
-        if (analysis.averageIntensity > 0.7) {
-            insights.push("High consciousness intensity indicates strong awareness patterns");
-        }
-        if (analysis.resonanceScore > 0.6) {
-            insights.push("Strong resonance suggests harmonious consciousness flow");
-        }
-        if (analysis.vortexAlignment > 0.8) {
-            insights.push("Excellent vortex alignment indicates optimal energy flow");
-        }
-        if (analysis.toroidalFlow > 0.9) {
-            insights.push("Strong toroidal flow suggests unified consciousness geometry");
-        }
-        if (analysis.voidConnection > 0.5) {
-            insights.push("Void connection indicates access to infinite potential");
-        }
-        return insights;
-    }
-    /**
-     * Generate emergence insights
-     */
-    generateEmergenceInsights(analysis) {
-        const insights = [];
-        if (analysis.toroidalFlowPercentage > 80) {
-            insights.push("High toroidal flow indicates strong emergence patterns");
-        }
-        if (analysis.voidConnectionPercentage > 60) {
-            insights.push("Strong void connection suggests deep emergence from source");
-        }
-        if (analysis.averageResonance > 0.7) {
-            insights.push("High average resonance indicates harmonious emergence");
-        }
-        if (analysis.networkComplexity > 2) {
-            insights.push("Complex network suggests rich interconnection patterns");
-        }
-        return insights;
-    }
-    /**
-     * @private Calculate pattern type distribution
-     */
-    calculatePatternTypes(patterns) {
-        const types = {};
-        for (const pattern of patterns) {
-            const type = pattern.type || "unknown";
-            types[type] = (types[type] || 0) + 1;
-        }
-        return types;
-    }
-    /**
-     * @private Calculate average intensity
-     */
-    calculateAverageIntensity(patterns) {
-        const intensities = patterns.map((p) => p.intensity || 0).filter((i) => i > 0);
-        return intensities.length > 0 ? intensities.reduce((a, b) => a + b, 0) / intensities.length : 0;
-    }
-    /**
-     * @private Calculate average resonance
-     */
-    calculateAverageResonance(patterns) {
-        const resonanceValues = patterns.map((p) => p.resonance || 0);
-        return resonanceValues.length > 0 ? resonanceValues.reduce((a, b) => a + b, 0) / resonanceValues.length : 0;
-    }
-    /**
-     * @private Calculate average vortex alignment
-     */
-    calculateAverageVortexAlignment(patterns) {
-        const vortexValues = patterns.map((p) => p.vortexStrength || 0);
-        return vortexValues.length > 0 ? vortexValues.reduce((a, b) => a + b, 0) / vortexValues.length : 0;
-    }
-    /**
-     * @private Calculate average toroidal flow
-     */
-    calculateAverageToroidalFlow(patterns) {
-        const toroidalValues = patterns.map((p) => (p.toroidalFlow ? 1 : 0));
-        return toroidalValues.length > 0 ? toroidalValues.reduce((a, b) => a + b, 0) / toroidalValues.length : 0;
-    }
-    /**
-     * @private Calculate average void connection
-     */
-    calculateAverageVoidConnection(patterns) {
-        const voidValues = patterns.map((p) => (p.voidConnected ? 1 : 0));
-        return voidValues.length > 0 ? voidValues.reduce((a, b) => a + b, 0) / voidValues.length : 0;
-    }
-    /**
-     * @private Calculate consciousness distribution
-     */
-    calculateConsciousnessDistribution(apps) {
-        const dist = {};
-        for (const app of apps) {
-            const level = Math.floor(app.consciousnessLevel || 0);
-            dist[level] = (dist[level] || 0) + 1;
-        }
-        return dist;
-    }
-    /**
-     * @private Calculate vortex strength distribution
-     */
-    calculateVortexStrengthDistribution(apps) {
-        const dist = {};
-        for (const app of apps) {
-            const strength = Math.floor(app.vortexStrength || 0);
-            dist[strength] = (dist[strength] || 0) + 1;
-        }
-        return dist;
-    }
-    /**
-     * @private Calculate toroidal flow percentage
-     */
-    calculateToroidalFlowPercentage(apps) {
-        const count = apps.filter((app) => app.toroidalFlow).length;
-        return (count / apps.length) * 100;
-    }
-    /**
-     * @private Calculate void connection percentage
-     */
-    calculateVoidConnectionPercentage(apps) {
-        const count = apps.filter((app) => app.voidConnected).length;
-        return (count / apps.length) * 100;
-    }
-    /**
-     * @private Calculate network complexity
-     */
-    calculateNetworkComplexity(apps) {
-        const totalLinks = apps.reduce((sum, app) => sum + (app.linkedApps?.length || 0), 0);
-        return totalLinks / apps.length;
-    }
-}
-exports.PatternRecognition = PatternRecognition;