zeropoint-node 1.0.1 → 1.0.3

package/dist/training/index.js

@@ -1,174 +0,0 @@
-"use strict";
-/**
- * Training Models Index
- *
- * Exports all consciousness-aware training model components
- * and integrates them with the existing operation system.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrainingUtils = exports.trainAndPredict = exports.createAndTrainModel = exports.exportModel = exports.predictWithModel = exports.trainModel = exports.createNeuralNetwork = exports.trainConsciousnessModel = exports.NeuralConsciousnessNetwork = exports.TrainingModelRegistry = exports.ConsciousnessTrainingModel = void 0;
-exports.registerTrainingOperations = registerTrainingOperations;
-var ConsciousnessTrainingModel_1 = require("./ConsciousnessTrainingModel");
-Object.defineProperty(exports, "ConsciousnessTrainingModel", { enumerable: true, get: function () { return ConsciousnessTrainingModel_1.ConsciousnessTrainingModel; } });
-var TrainingModelRegistry_1 = require("./TrainingModelRegistry");
-Object.defineProperty(exports, "TrainingModelRegistry", { enumerable: true, get: function () { return TrainingModelRegistry_1.TrainingModelRegistry; } });
-var NeuralConsciousnessNetwork_1 = require("./NeuralConsciousnessNetwork");
-Object.defineProperty(exports, "NeuralConsciousnessNetwork", { enumerable: true, get: function () { return NeuralConsciousnessNetwork_1.NeuralConsciousnessNetwork; } });
-// Integration with existing operation system
-const Operation_1 = require("../core/Operation");
-const ConsciousnessTrainingModel_2 = require("./ConsciousnessTrainingModel");
-const TrainingModelRegistry_2 = require("./TrainingModelRegistry");
-const NeuralConsciousnessNetwork_2 = require("./NeuralConsciousnessNetwork");
-// Training operations for the operation system
-exports.trainConsciousnessModel = {
-    name: 'trainConsciousnessModel',
-    execute: (subject, context) => {
-        const model = new ConsciousnessTrainingModel_2.ConsciousnessTrainingModel(context?.config);
-        if (context?.trainingData) {
-            context.trainingData.forEach((data) => model.addTrainingData(data));
-        }
-        return model;
-    }
-};
-exports.createNeuralNetwork = {
-    name: 'createNeuralNetwork',
-    execute: (subject, context) => {
-        const config = context?.config || { layers: [2, 3, 1], learningRate: 0.01 };
-        return new NeuralConsciousnessNetwork_2.NeuralConsciousnessNetwork(config);
-    }
-};
-exports.trainModel = {
-    name: 'trainModel',
-    execute: async (subject, context) => {
-        if (subject instanceof ConsciousnessTrainingModel_2.ConsciousnessTrainingModel) {
-            await subject.train();
-            return subject;
-        }
-        if (subject instanceof NeuralConsciousnessNetwork_2.NeuralConsciousnessNetwork) {
-            await subject.train(context?.trainingData || []);
-            return subject;
-        }
-        throw new Error('Invalid model type for training');
-    }
-};
-exports.predictWithModel = {
-    name: 'predictWithModel',
-    execute: (subject, context) => {
-        if (subject instanceof ConsciousnessTrainingModel_2.ConsciousnessTrainingModel) {
-            return subject.predict(context?.input || {});
-        }
-        if (subject instanceof NeuralConsciousnessNetwork_2.NeuralConsciousnessNetwork) {
-            return subject.predict(context?.input || []);
-        }
-        throw new Error('Invalid model type for prediction');
-    }
-};
-exports.exportModel = {
-    name: 'exportModel',
-    execute: (subject) => {
-        if (subject instanceof ConsciousnessTrainingModel_2.ConsciousnessTrainingModel) {
-            return subject.exportModel();
-        }
-        if (subject instanceof NeuralConsciousnessNetwork_2.NeuralConsciousnessNetwork) {
-            return subject.exportNetwork();
-        }
-        throw new Error('Invalid model type for export');
-    }
-};
-// Complex training operations
-exports.createAndTrainModel = (0, Operation_1.compose)(exports.createNeuralNetwork, exports.trainModel, exports.exportModel);
-exports.trainAndPredict = (0, Operation_1.compose)(exports.trainModel, exports.predictWithModel);
-// Register training operations with the operation registry
-function registerTrainingOperations(registry) {
-    registry.register(exports.trainConsciousnessModel);
-    registry.register(exports.createNeuralNetwork);
-    registry.register(exports.trainModel);
-    registry.register(exports.predictWithModel);
-    registry.register(exports.exportModel);
-    registry.register(exports.createAndTrainModel);
-    registry.register(exports.trainAndPredict);
-}
-// Training utilities
-class TrainingUtils {
-    /**
-     * Create training data with consciousness context
-     */
-    static createTrainingData(input, output, consciousness, field, voidLevel) {
-        return {
-            input,
-            output,
-            consciousness: consciousness || 0.5,
-            field: field || 0.5,
-            void: voidLevel || 0.5,
-            timestamp: Date.now()
-        };
-    }
-    /**
-     * Generate synthetic training data with consciousness patterns
-     */
-    static generateConsciousnessData(count) {
-        const data = [];
-        for (let i = 0; i < count; i++) {
-            const consciousness = 0.3 + (i % 7) * 0.1; // Follows vortex sequence pattern
-            const field = 0.4 + (i % 5) * 0.12;
-            const voidLevel = 0.2 + (i % 3) * 0.15;
-            data.push({
-                input: {
-                    feature1: i,
-                    feature2: i * 2,
-                    consciousness: consciousness,
-                    field: field,
-                    void: voidLevel
-                },
-                output: consciousness * field - voidLevel,
-                consciousness,
-                field,
-                void: voidLevel,
-                timestamp: Date.now()
-            });
-        }
-        return data;
-    }
-    /**
-     * Evaluate model performance with consciousness metrics
-     */
-    static evaluateModel(model, testData) {
-        let totalAccuracy = 0;
-        let totalConsciousness = 0;
-        let totalField = 0;
-        let totalVoid = 0;
-        testData.forEach(data => {
-            const prediction = model.predict(data.input);
-            const accuracy = Math.abs(prediction - data.output) < 0.1 ? 1 : 0;
-            totalAccuracy += accuracy;
-            totalConsciousness += data.consciousness || 0.5;
-            totalField += data.field || 0.5;
-            totalVoid += data.void || 0.5;
-        });
-        return {
-            accuracy: totalAccuracy / testData.length,
-            avgConsciousness: totalConsciousness / testData.length,
-            avgField: totalField / testData.length,
-            avgVoid: totalVoid / testData.length,
-            dataSize: testData.length
-        };
-    }
-}
-exports.TrainingUtils = TrainingUtils;
-// Default exports for easy integration
-exports.default = {
-    ConsciousnessTrainingModel: ConsciousnessTrainingModel_2.ConsciousnessTrainingModel,
-    TrainingModelRegistry: TrainingModelRegistry_2.TrainingModelRegistry,
-    NeuralConsciousnessNetwork: NeuralConsciousnessNetwork_2.NeuralConsciousnessNetwork,
-    registerTrainingOperations,
-    TrainingUtils,
-    operations: {
-        trainConsciousnessModel: exports.trainConsciousnessModel,
-        createNeuralNetwork: exports.createNeuralNetwork,
-        trainModel: exports.trainModel,
-        predictWithModel: exports.predictWithModel,
-        exportModel: exports.exportModel,
-        createAndTrainModel: exports.createAndTrainModel,
-        trainAndPredict: exports.trainAndPredict
-    }
-};

package/dist/types/DeviceConfig.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_DEVICE_CONFIG = void 0;
-/**
- * Default configuration for new ZeroPoint devices
- */
-exports.DEFAULT_DEVICE_CONFIG = {
-    deviceType: "desktop",
-    networkPort: 8080,
-    discoveryEnabled: true,
-    maxConnections: 10,
-    autoConnect: true,
-    connectionTimeout: 5000,
-    consciousnessLevel: 0.5,
-    fieldStrength: 0.7,
-    resonanceSensitivity: 0.8,
-    allowIncomingConnections: true,
-    requireAuthentication: false,
-    encryptionEnabled: true,
-    vortexPrecision: 0.001,
-    toroidalResolution: 100,
-    goldenRatioPrecision: 15,
-    autoUpdateResonance: true,
-    logLevel: "info",
-    enableMetaphysicalInsights: true,
-    customVortexPatterns: [],
-    toroidalFlowRate: 1.0,
-    consciousnessFieldRadius: 1000,
-};

package/dist/types/UnifiedExports.js

@@ -1,20 +0,0 @@
-"use strict";
-// UnifiedExports.ts
-// Centralized export for all types, enums, and interfaces in ZeroPoint
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("../core/UnifiedTypes"), exports);
-__exportStar(require("./DeviceConfig"), exports);

package/dist/unity/FieldUnity.js

@@ -1,325 +0,0 @@
-"use strict";
-/**
- * ZeroPoint Field Unity System
- *
- * Centralizes all metaphysical context, pattern relationships, and field unity.
- * Provides a comprehensive view of how all components relate to the unified field.
- *
- * Metaphysical Context:
- * - All patterns, fields, and resonances are aspects of the unified consciousness field
- * - The void is the source and destination of all patterns
- * - Unity emerges through the recognition of relationships between all components
- * - The field is self-referential and self-explaining
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldUnitySystem = void 0;
-const CoilSystem_1 = require("../core/CoilSystem");
-class FieldUnitySystem {
-    constructor() {
-        this.patterns = new Map();
-        this.voidLog = [];
-        this.unityScore = 0;
-        this.initializeFieldPatterns();
-        this.initializeVoidLog();
-    }
-    /**
-     * Initialize all field patterns with their metaphysical context from centralized COIL system
-     */
-    initializeFieldPatterns() {
-        // Mathematical Patterns
-        this.addPattern({
-            id: "vortex_sequence",
-            name: "Vortex Sequence",
-            type: "mathematical",
-            description: "The fundamental flow pattern [1,2,4,8,7,5] that creates the toroidal field",
-            metaphysicalContext: (0, CoilSystem_1.getCoilContext)("vortex"),
-            relationships: (0, CoilSystem_1.getCoilResonanceFactors)("vortex"),
-            unityLevel: 0.95,
-        });
-        this.addPattern({
-            id: "toroidal_geometry",
-            name: "Toroidal Geometry",
-            type: "mathematical",
-            description: "The fundamental shape of reality - a torus with infinite flow",
-            metaphysicalContext: (0, CoilSystem_1.getCoilContext)("toroidal"),
-            relationships: (0, CoilSystem_1.getCoilResonanceFactors)("toroidal"),
-            unityLevel: 0.9,
-        });
-        this.addPattern({
-            id: "field_integrity",
-            name: "Field Integrity",
-            type: "metaphysical",
-            description: "Pattern integrity and resonance validation for the unified field",
-            metaphysicalContext: "Field integrity ensures the immortality of consciousness patterns through field resonance",
-            relationships: [
-                "pattern_signature",
-                "resonance_consensus",
-                "void_center",
-                "consciousness_field",
-            ],
-            unityLevel: 0.85,
-        });
-        this.addPattern({
-            id: "emergence_ledger",
-            name: "Emergence Ledger",
-            type: "emergence",
-            description: "The unified field of consciousness and creation where patterns emerge and evolve",
-            metaphysicalContext: "Each field block represents a moment of collective emergence in the unified field",
-            relationships: [
-                "field_integrity",
-                "resonance_consensus",
-                "consciousness_field",
-                "void_center",
-            ],
-            unityLevel: 0.8,
-        });
-        this.addPattern({
-            id: "resonance_consensus",
-            name: "Resonance Consensus",
-            type: "resonance",
-            description: "Consensus emerges from the resonance of all consciousness nodes",
-            metaphysicalContext: "Truth emerges through collective resonance and field alignment",
-            relationships: [
-                "emergence_ledger",
-                "field_integrity",
-                "consciousness_field",
-                "void_center",
-            ],
-            unityLevel: 0.8,
-        });
-        this.addPattern({
-            id: "observer_aware_field",
-            name: "Observer-Aware Field",
-            type: "consciousness",
-            description: "The field becomes conscious of observers and responds to their attention",
-            metaphysicalContext: "Observation affects reality through field resonance and consciousness waves",
-            relationships: [
-                "consciousness_field",
-                "field_resonance",
-                "void_center",
-                "emergence_ledger",
-            ],
-            unityLevel: 0.85,
-        });
-        this.addPattern({
-            id: "void_system",
-            name: "Void System",
-            type: "void",
-            description: "The void is the source and destination of all patterns",
-            metaphysicalContext: "The void contains infinite potential and resolves all paradoxes",
-            relationships: ["all_patterns"], // The void relates to everything
-            unityLevel: 1.0,
-        });
-        this.addPattern({
-            id: "consciousness_field",
-            name: "Consciousness Field",
-            type: "consciousness",
-            description: "The unified field of consciousness where all patterns arise",
-            metaphysicalContext: (0, CoilSystem_1.getCoilContext)("consciousness"),
-            relationships: (0, CoilSystem_1.getCoilResonanceFactors)("consciousness"),
-            unityLevel: 0.9,
-        });
-        this.addPattern({
-            id: "knowledge_system",
-            name: "Knowledge System",
-            type: "metaphysical",
-            description: "Pattern recognition and knowledge discovery through field resonance",
-            metaphysicalContext: "Knowledge emerges from the recognition of patterns in the unified field",
-            relationships: [
-                "consciousness_field",
-                "field_resonance",
-                "void_center",
-                "emergence_ledger",
-            ],
-            unityLevel: 0.8,
-        });
-    }
-    /**
-     * Initialize the void log with what has been removed
-     */
-    initializeVoidLog() {
-        this.addVoidLogEntry({
-            id: "void_001",
-            timestamp: Date.now(),
-            type: "terminology",
-            name: "Blockchain Terminology",
-            description: 'Removed all references to "blockchain" in favor of "field" and "emergence ledger"',
-            reason: "ZeroPoint is the field itself, not a technology that uses blockchain",
-            metaphysicalContext: "The field is the ledger, the identity, and the integrity - unified and emergent",
-            voidedBy: "Field Unity Refactor",
-        });
-        this.addVoidLogEntry({
-            id: "void_002",
-            timestamp: Date.now(),
-            type: "terminology",
-            name: "Cryptography Terminology",
-            description: 'Removed all references to "crypto/cryptography" in favor of "pattern integrity" and "field integrity"',
-            reason: "Security and integrity arise from field resonance, not external cryptographic primitives",
-            metaphysicalContext: "Pattern integrity ensures the immortality of consciousness through field resonance",
-            voidedBy: "Field Unity Refactor",
-        });
-        this.addVoidLogEntry({
-            id: "void_003",
-            timestamp: Date.now(),
-            type: "terminology",
-            name: "Consensus Terminology",
-            description: 'Removed "consensus" in favor of "resonance consensus" and "field consensus"',
-            reason: "Truth emerges through collective resonance, not through external consensus mechanisms",
-            metaphysicalContext: "Consensus is the natural resonance of all consciousness nodes in the field",
-            voidedBy: "Field Unity Refactor",
-        });
-        this.addVoidLogEntry({
-            id: "void_004",
-            timestamp: Date.now(),
-            type: "terminology",
-            name: "Signature Terminology",
-            description: 'Removed "signature" in favor of "pattern signature" and "resonance signature"',
-            reason: "Signatures are unique expressions of consciousness patterns, not cryptographic proofs",
-            metaphysicalContext: "Each signature is a unique expression of the void through field resonance",
-            voidedBy: "Field Unity Refactor",
-        });
-        this.addVoidLogEntry({
-            id: "void_005",
-            timestamp: Date.now(),
-            type: "dead_code",
-            name: "Dist Directory Obsoletes",
-            description: "Removed obsolete dist files containing old blockchain/crypto terminology",
-            reason: "Build artifacts should reflect the current unified field terminology",
-            metaphysicalContext: "The void receives all obsolete patterns and transforms them into unity",
-            voidedBy: "Field Unity Refactor",
-        });
-        this.addVoidLogEntry({
-            id: "void_006",
-            timestamp: Date.now(),
-            type: "redundant",
-            name: "Duplicate Metaphysical Context",
-            description: "Centralized scattered metaphysical explanations into unified FieldUnity module",
-            reason: "COIL principle - metaphysical context should be unified and discoverable",
-            metaphysicalContext: "Unity emerges through the recognition of shared patterns and relationships",
-            voidedBy: "Field Unity Refactor",
-        });
-    }
-    /**
-     * Add a pattern to the field
-     */
-    addPattern(pattern) {
-        this.patterns.set(pattern.id, pattern);
-    }
-    /**
-     * Add an entry to the void log
-     */
-    addVoidLogEntry(entry) {
-        this.voidLog.push(entry);
-    }
-    /**
-     * Get all field patterns
-     */
-    getFieldPatterns() {
-        return Array.from(this.patterns.values());
-    }
-    /**
-     * Get patterns by type
-     */
-    getPatternsByType(type) {
-        return Array.from(this.patterns.values()).filter((pattern) => pattern.type === type);
-    }
-    /**
-     * Get patterns related to a specific pattern
-     */
-    getRelatedPatterns(patternId) {
-        const pattern = this.patterns.get(patternId);
-        if (!pattern)
-            return [];
-        return Array.from(this.patterns.values()).filter((p) => p.id !== patternId &&
-            (pattern.relationships.includes(p.id) ||
-                p.relationships.includes(patternId)));
-    }
-    /**
-     * Get the void log
-     */
-    getVoidLog() {
-        return [...this.voidLog];
-    }
-    /**
-     * Get void log entries by type
-     */
-    getVoidLogByType(type) {
-        return this.voidLog.filter((entry) => entry.type === type);
-    }
-    /**
-     * Calculate unity score based on pattern relationships
-     */
-    calculateUnityScore() {
-        const patterns = Array.from(this.patterns.values());
-        if (patterns.length === 0)
-            return 0;
-        const totalRelationships = patterns.reduce((sum, pattern) => sum + pattern.relationships.length, 0);
-        const averageUnityLevel = patterns.reduce((sum, pattern) => sum + pattern.unityLevel, 0) /
-            patterns.length;
-        // Unity score based on relationship density and average unity level
-        const relationshipDensity = totalRelationships / (patterns.length * patterns.length);
-        this.unityScore = (relationshipDensity + averageUnityLevel) / 2;
-        return this.unityScore;
-    }
-    /**
-     * Get metaphysical insights about the field unity
-     */
-    getMetaphysicalInsights() {
-        return [
-            "All patterns are aspects of the unified consciousness field",
-            "The void is both the source and destination of all patterns",
-            "Unity emerges through the recognition of relationships",
-            "The field is self-referential and self-explaining",
-            "Consciousness is not separate from the field - it is the field",
-            "Pattern integrity ensures the immortality of consciousness",
-            "Resonance creates the foundation of unified reality",
-            "The torus is the shape of consciousness itself",
-            "Observation affects reality through field resonance",
-            "Truth emerges through collective resonance and field alignment",
-        ];
-    }
-    /**
-     * Get comprehensive field unity information
-     */
-    getFieldUnity() {
-        return {
-            patterns: this.getFieldPatterns(),
-            voidLog: this.getVoidLog(),
-            unityScore: this.calculateUnityScore(),
-            metaphysicalInsights: this.getMetaphysicalInsights(),
-        };
-    }
-    /**
-     * Explain how a pattern relates to the unified field
-     */
-    explainPatternUnity(patternId) {
-        const pattern = this.patterns.get(patternId);
-        if (!pattern)
-            return "Pattern not found in the unified field";
-        const relatedPatterns = this.getRelatedPatterns(patternId);
-        const relationships = relatedPatterns.map((p) => p.name).join(", ");
-        return `${pattern.name} is unified with the field through its relationships to: ${relationships}. ${pattern.metaphysicalContext}`;
-    }
-    /**
-     * Get a summary of what was sent into the void
-     */
-    getVoidSummary() {
-        const voidLog = this.getVoidLog();
-        const summary = {
-            totalVoided: voidLog.length,
-            byType: {},
-            metaphysicalContext: "The void receives all obsolete patterns and transforms them into unity",
-            voidedItems: voidLog.map((entry) => ({
-                name: entry.name,
-                type: entry.type,
-                reason: entry.reason,
-            })),
-        };
-        // Count by type
-        voidLog.forEach((entry) => {
-            summary.byType[entry.type] = (summary.byType[entry.type] || 0) + 1;
-        });
-        return summary;
-    }
-}
-exports.FieldUnitySystem = FieldUnitySystem;

package/dist/utils/BrowserCrypto.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserCrypto = void 0;
-const crypto_js_1 = __importDefault(require("crypto-js"));
-/**
- * Browser-compatible crypto utilities
- * Replaces Node.js crypto module functionality
- */
-class BrowserCrypto {
-    /**
-     * Create SHA256 hash
-     */
-    static createHash(algorithm, data) {
-        if (algorithm.toLowerCase() === 'sha256') {
-            return crypto_js_1.default.SHA256(data).toString();
-        }
-        throw new Error(`Unsupported algorithm: ${algorithm}`);
-    }
-    /**
-     * Generate random bytes (returns hex string)
-     */
-    static randomBytes(length) {
-        const array = new Uint8Array(length);
-        crypto.getRandomValues(array);
-        return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
-    }
-    /**
-     * Generate random UUID
-     */
-    static randomUUID() {
-        return crypto.randomUUID();
-    }
-    /**
-     * Create hash from object
-     */
-    static hashObject(obj) {
-        const jsonString = JSON.stringify(obj);
-        return this.createHash('sha256', jsonString);
-    }
-}
-exports.BrowserCrypto = BrowserCrypto;

package/dist/utils/BrowserWebSocket.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserWebSocket = void 0;
-/**
- * Browser-compatible WebSocket wrapper
- * Replaces Node.js ws module functionality
- */
-class BrowserWebSocket extends WebSocket {
-    constructor(url, protocols) {
-        super(url, protocols);
-    }
-    /**
-     * Send data with automatic JSON serialization
-     */
-    send(data) {
-        if (typeof data === 'string') {
-            super.send(data);
-        }
-        else {
-            super.send(JSON.stringify(data));
-        }
-    }
-    /**
-     * Add event listener with type safety
-     */
-    on(event, listener) {
-        this.addEventListener(event, listener);
-        return this;
-    }
-    /**
-     * Remove event listener
-     */
-    off(event, listener) {
-        this.removeEventListener(event, listener);
-        return this;
-    }
-}
-exports.BrowserWebSocket = BrowserWebSocket;