zeropoint-node 1.0.0 → 1.0.1

package/dist/core/Observer.js

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

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

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

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

package/dist/core/PatternRecognition.js

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