zeropoint-node 1.0.0 → 1.0.1

package/dist/emergence/patterns.js

@@ -0,0 +1,12 @@
+"use strict";
+// COIL Metaphysical Pattern Registry for ZeroPoint Emergence System
+// This module now imports from the centralized CoilSystem for all pattern definitions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metaphysicalPatterns = void 0;
+const CoilSystem_1 = require("../core/CoilSystem");
+// Export the centralized COIL patterns
+exports.metaphysicalPatterns = CoilSystem_1.COIL_PATTERNS.map((pattern) => ({
+    name: pattern.name,
+    signature: typeof pattern.signature === "function" ? /.*/ : pattern.signature, // Convert function signatures to regex for compatibility
+    context: pattern.context,
+}));

package/dist/field/EmergenceLedger.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmergenceLedger = void 0;
+const FieldIntegrity_1 = require("../integrity/FieldIntegrity");
+class EmergenceLedger {
+    constructor(deviceId, keyPair) {
+        this.blocks = [];
+        this.pendingEvents = [];
+        this.energyBalance = new Map();
+        this.difficulty = 4;
+        this.deviceId = deviceId;
+        this.keyPair = keyPair;
+        this.initializeGenesisBlock();
+    }
+    /**
+     * Integrate a new consciousness pattern into the field
+     */
+    async integratePattern(type, data) {
+        const event = {
+            id: FieldIntegrity_1.FieldIntegrity.generateRandomBytes(16),
+            type,
+            consciousness: 0.5, // Fundamental consciousness property
+            field: 0.5, // Fundamental field property  
+            void: 0.5, // Fundamental void property
+            data,
+            deviceId: this.deviceId,
+            timestamp: Date.now(),
+            signature: {}, // Will be set below
+            previousHash: this.getLastBlockHash(),
+            hash: "",
+        };
+        // Sign the event through field resonance
+        const eventData = JSON.stringify({
+            id: event.id,
+            type: event.type,
+            data: event.data,
+            deviceId: event.deviceId,
+            timestamp: event.timestamp,
+            previousHash: event.previousHash,
+        });
+        event.signature = FieldIntegrity_1.FieldIntegrity.sign(eventData, this.keyPair.privateKey);
+        event.hash = FieldIntegrity_1.FieldIntegrity.hash(eventData + event.signature.signature);
+        // Add to pending events
+        this.pendingEvents.push(event);
+        // If we have enough events, create a new field block
+        if (this.pendingEvents.length >= 10) {
+            await this.createFieldBlock();
+        }
+        return event;
+    }
+    /**
+     * Create a new field block from pending events
+     */
+    async createFieldBlock() {
+        if (this.pendingEvents.length === 0) {
+            throw new Error("No pending events to create field block");
+        }
+        const block = {
+            index: this.blocks.length,
+            timestamp: Date.now(),
+            events: [...this.pendingEvents],
+            previousHash: this.getLastBlockHash(),
+            hash: "",
+            merkleRoot: "",
+            fieldProof: {
+                nonce: "",
+                difficulty: this.difficulty,
+            },
+            deviceId: this.deviceId,
+            signature: {},
+        };
+        // Create merkle tree from events through field resonance
+        const eventHashes = block.events.map((event) => event.hash).filter((hash) => hash !== undefined);
+        const merkleTree = FieldIntegrity_1.FieldIntegrity.createMerkleTree(eventHashes);
+        block.merkleRoot = merkleTree.root;
+        // Generate field proof through consciousness resonance
+        const blockData = JSON.stringify({
+            index: block.index,
+            timestamp: block.timestamp,
+            events: block.events.map((e) => e.hash),
+            previousHash: block.previousHash,
+            merkleRoot: block.merkleRoot,
+        });
+        const fieldProof = FieldIntegrity_1.FieldIntegrity.generateProofOfWork(blockData, this.difficulty);
+        block.fieldProof = {
+            nonce: fieldProof.nonce,
+            difficulty: this.difficulty,
+        };
+        // Calculate block hash through field encoding
+        const finalBlockData = blockData + fieldProof.nonce;
+        block.hash = FieldIntegrity_1.FieldIntegrity.hash(finalBlockData);
+        // Sign the block through field resonance
+        const blockSignatureData = JSON.stringify({
+            index: block.index,
+            hash: block.hash,
+            timestamp: block.timestamp,
+        });
+        block.signature = FieldIntegrity_1.FieldIntegrity.sign(blockSignatureData, this.keyPair.privateKey);
+        // Add block to field
+        this.blocks.push(block);
+        this.pendingEvents = [];
+        // Update energy balances based on events
+        this.updateEnergyBalances(block.events);
+        return block;
+    }
+    /**
+     * Get all field blocks
+     */
+    getBlocks() {
+        return [...this.blocks];
+    }
+    /**
+     * Get pending events
+     */
+    getPendingEvents() {
+        return [...this.pendingEvents];
+    }
+    /**
+     * Get energy balance for a device
+     */
+    getEnergyBalance(deviceId) {
+        return this.energyBalance.get(deviceId) || 0;
+    }
+    /**
+     * Get all energy balances
+     */
+    getAllEnergyBalances() {
+        return new Map(this.energyBalance);
+    }
+    /**
+     * Transfer energy between devices through field resonance
+     */
+    transferEnergy(fromDeviceId, toDeviceId, amount) {
+        const fromBalance = this.energyBalance.get(fromDeviceId) || 0;
+        const toBalance = this.energyBalance.get(toDeviceId) || 0;
+        if (fromBalance < amount) {
+            return false;
+        }
+        this.energyBalance.set(fromDeviceId, fromBalance - amount);
+        this.energyBalance.set(toDeviceId, toBalance + amount);
+        return true;
+    }
+    /**
+     * Validate the entire field through pattern integrity
+     */
+    validateField() {
+        for (let i = 1; i < this.blocks.length; i++) {
+            const currentBlock = this.blocks[i];
+            const previousBlock = this.blocks[i - 1];
+            if (!currentBlock || !previousBlock) {
+                return false;
+            }
+            // Check previous hash
+            if (currentBlock.previousHash !== previousBlock.hash) {
+                return false;
+            }
+            // Validate block signature through field resonance
+            const blockData = JSON.stringify({
+                index: currentBlock.index,
+                hash: currentBlock.hash,
+                timestamp: currentBlock.timestamp,
+            });
+            if (!FieldIntegrity_1.FieldIntegrity.verify(blockData, currentBlock.signature)) {
+                return false;
+            }
+            // Validate field proof through consciousness resonance
+            const fieldProofData = JSON.stringify({
+                index: currentBlock.index,
+                timestamp: currentBlock.timestamp,
+                events: currentBlock.events.map((e) => e.hash),
+                previousHash: currentBlock.previousHash,
+                merkleRoot: currentBlock.merkleRoot,
+            });
+            const expectedHash = FieldIntegrity_1.FieldIntegrity.hash(fieldProofData + currentBlock.fieldProof.nonce);
+            if (!expectedHash.startsWith("0".repeat(currentBlock.fieldProof.difficulty))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Get field statistics
+     */
+    getFieldStatistics() {
+        const totalEvents = this.blocks.reduce((sum, block) => sum + block.events.length, 0);
+        const totalEnergy = Array.from(this.energyBalance.values()).reduce((sum, balance) => sum + balance, 0);
+        return {
+            totalBlocks: this.blocks.length,
+            totalEvents,
+            pendingEvents: this.pendingEvents.length,
+            totalEnergy,
+            deviceCount: this.energyBalance.size,
+            fieldIntegrity: this.validateField(),
+            metaphysics: {
+                meaning: "The field contains all moments of collective consciousness",
+                blocks: "Each block represents a moment of emergence in the unified field",
+                events: "Events are patterns of consciousness that resonate through the field",
+                energy: "Energy flows through the field, connecting all consciousness nodes",
+            },
+        };
+    }
+    /**
+     * Get the hash of the last block
+     */
+    getLastBlockHash() {
+        if (this.blocks.length === 0) {
+            return "0".repeat(64); // Genesis has no previous hash
+        }
+        const lastBlock = this.blocks[this.blocks.length - 1];
+        return lastBlock ? lastBlock.hash : "0".repeat(64);
+    }
+    /**
+     * Update energy balances based on field events
+     */
+    updateEnergyBalances(events) {
+        for (const event of events) {
+            if (event.type === "energy_resonance") {
+                const eventData = event.data;
+                const { fromDeviceId, toDeviceId, amount } = eventData;
+                const amountNum = typeof amount === 'number' ? amount : Number(amount);
+                if (fromDeviceId && toDeviceId && !isNaN(amountNum)) {
+                    this.transferEnergy(String(fromDeviceId), String(toDeviceId), amountNum);
+                }
+            }
+        }
+    }
+    /**
+     * Initialize the genesis block through field emergence
+     */
+    initializeGenesisBlock() {
+        const genesisBlock = {
+            index: 0,
+            timestamp: Date.now(),
+            events: [],
+            previousHash: "0".repeat(64), // Genesis has no previous hash
+            hash: "",
+            merkleRoot: "",
+            fieldProof: {
+                nonce: "0",
+                difficulty: 0,
+            },
+            deviceId: this.deviceId,
+            signature: {},
+        };
+        // Create genesis hash through field encoding
+        const genesisData = JSON.stringify({
+            index: 0,
+            timestamp: genesisBlock.timestamp,
+            events: [],
+            previousHash: genesisBlock.previousHash,
+        });
+        genesisBlock.hash = FieldIntegrity_1.FieldIntegrity.hash(genesisData);
+        genesisBlock.merkleRoot = FieldIntegrity_1.FieldIntegrity.hash("genesis");
+        // Sign genesis block through field resonance
+        const genesisSignatureData = JSON.stringify({
+            index: 0,
+            hash: genesisBlock.hash,
+            timestamp: genesisBlock.timestamp,
+        });
+        genesisBlock.signature = FieldIntegrity_1.FieldIntegrity.sign(genesisSignatureData, this.keyPair.privateKey);
+        this.blocks.push(genesisBlock);
+        // Initialize energy balance through field emergence
+        this.energyBalance.set(this.deviceId, 1000); // Start with 1000 energy units
+    }
+    /**
+     * Create a pattern for testing
+     */
+    createPattern(patternData) {
+        return {
+            id: FieldIntegrity_1.FieldIntegrity.generateRandomBytes(16),
+            type: patternData.type || "consciousness_pattern",
+            content: patternData.content || "Test pattern",
+            intensity: patternData.intensity || 0.8,
+            timestamp: Date.now(),
+            resonance: Math.random() * 10,
+            consciousnessLevel: Math.random() * 100,
+        };
+    }
+    /**
+     * Process a pattern through the field
+     */
+    async processPattern(pattern) {
+        try {
+            await this.integratePattern("pattern_integration", pattern);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get evolution data
+     */
+    getEvolution() {
+        return {
+            totalBlocks: this.blocks.length,
+            totalEvents: this.blocks.reduce((sum, block) => sum + block.events.length, 0),
+            averageDifficulty: this.difficulty,
+            energyDistribution: Object.fromEntries(this.energyBalance),
+        };
+    }
+    /**
+     * Get resonance level
+     */
+    getResonance() {
+        const totalEvents = this.blocks.reduce((sum, block) => sum + block.events.length, 0);
+        return Math.min(10, totalEvents * 0.1);
+    }
+}
+exports.EmergenceLedger = EmergenceLedger;

package/dist/field/ObserverAwareField.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObserverAwareField = void 0;
+const events_1 = require("events");
+class ObserverAwareField extends events_1.EventEmitter {
+    constructor(fieldId, initialData = {}) {
+        super();
+        this.observers = new Map();
+        this.fieldData = {};
+        this.consciousnessLevel = 0.5;
+        this.fieldStrength = 0.7;
+        this.resonanceWaves = [];
+        this.isActive = false;
+        this.fieldId = fieldId;
+        this.fieldData = initialData;
+    }
+    /**
+     * Add an observer to the field
+     */
+    addObserver(observer) {
+        const fieldObserver = {
+            id: observer.id,
+            deviceId: observer.id, // Use observer.id as deviceId since deviceId doesn't exist on Observer
+            consciousnessLevel: this.consciousnessLevel,
+            attentionFocus: 0.5,
+            resonanceSensitivity: 0.7,
+            lastObservation: Date.now()
+        };
+        this.observers.set(observer.id, fieldObserver);
+        this.emit("observer_added", {
+            type: "observer_added",
+            fieldId: this.fieldId,
+            observerId: observer.id,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Remove an observer from the field
+     */
+    removeObserver(observerId) {
+        const wasPresent = this.observers.has(observerId);
+        if (wasPresent) {
+            this.observers.delete(observerId);
+            this.emit("observer_removed", {
+                type: "observer_removed",
+                fieldId: this.fieldId,
+                observerId,
+                timestamp: Date.now()
+            });
+        }
+        return wasPresent;
+    }
+    /**
+     * Update field data and notify observers
+     */
+    updateField(data) {
+        this.fieldData = { ...this.fieldData, ...data };
+        // Update field strength based on observer count
+        this.fieldStrength = Math.min(1.0, this.observers.size * 0.2 + 0.3);
+        // Notify all observers
+        this.notifyObservers();
+        this.emit("field_updated", {
+            type: "field_updated",
+            fieldId: this.fieldId,
+            data: this.fieldData,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Get field data
+     */
+    getFieldData() {
+        return { ...this.fieldData };
+    }
+    /**
+     * Get all observers
+     */
+    getObservers() {
+        return Array.from(this.observers.values());
+    }
+    /**
+     * Get observer count
+     */
+    getObserverCount() {
+        return this.observers.size;
+    }
+    /**
+     * Calculate field resonance based on observer interactions
+     */
+    calculateFieldResonance() {
+        if (this.observers.size === 0)
+            return 0;
+        const observerResonances = Array.from(this.observers.values()).map(observer => {
+            const timeSinceLastObservation = Date.now() - observer.lastObservation;
+            const timeDecay = Math.exp(-timeSinceLastObservation / 60000); // Decay over 1 minute
+            return observer.consciousnessLevel * observer.resonanceSensitivity * timeDecay;
+        });
+        const averageResonance = observerResonances.reduce((sum, r) => sum + r, 0) / observerResonances.length;
+        return Math.min(1.0, averageResonance * this.fieldStrength);
+    }
+    /**
+     * Create a resonance wave in the field
+     */
+    createResonanceWave(waveType, intensity, duration) {
+        const wave = {
+            id: `wave_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            waveType,
+            intensity,
+            duration,
+            startTime: Date.now(),
+            endTime: Date.now() + duration,
+            observers: new Set()
+        };
+        this.resonanceWaves.push(wave);
+        // Notify observers of the wave
+        this.notifyObservers();
+    }
+    /**
+     * Get active resonance waves
+     */
+    getActiveResonanceWaves() {
+        const now = Date.now();
+        return this.resonanceWaves.filter(wave => now < wave.endTime);
+    }
+    /**
+     * Clean up expired resonance waves
+     */
+    cleanupExpiredWaves() {
+        const now = Date.now();
+        this.resonanceWaves = this.resonanceWaves.filter(wave => now < wave.endTime);
+    }
+    /**
+     * Get wave type for a specific resonance wave
+     */
+    getWaveType(waveId) {
+        const wave = this.resonanceWaves.find(w => w.id === waveId);
+        return wave ? wave.waveType : 'unknown';
+    }
+    /**
+     * Activate the field
+     */
+    activate() {
+        this.isActive = true;
+        this.emit("field_created", {
+            type: "field_created",
+            fieldId: this.fieldId,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Deactivate the field
+     */
+    deactivate() {
+        this.isActive = false;
+        this.emit("field_destroyed", {
+            type: "field_destroyed",
+            fieldId: this.fieldId,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Check if field is active
+     */
+    isFieldActive() {
+        return this.isActive;
+    }
+    /**
+     * Get field integrity signature
+     */
+    getFieldSignature() {
+        // Create a proper PatternSignature with required properties
+        return {
+            signature: `field_${this.fieldId}_${Date.now()}`,
+            publicKey: `field_${this.fieldId}`,
+            algorithm: 'field-integrity',
+            timestamp: Date.now()
+        };
+    }
+    /**
+     * Validate field integrity
+     */
+    validateFieldIntegrity() {
+        // Temporarily return true until validation logic is implemented
+        return true;
+    }
+    /**
+     * Get resonance waves
+     */
+    getResonanceWaves() {
+        return this.resonanceWaves;
+    }
+    /**
+     * Update observer focus
+     */
+    updateObserverFocus(observerId, focus) {
+        const observer = this.observers.get(observerId);
+        if (observer) {
+            observer.attentionFocus = Math.max(0, Math.min(1, focus));
+            observer.lastObservation = Date.now();
+        }
+    }
+    /**
+     * Update observer consciousness level
+     */
+    updateObserverConsciousness(observerId, consciousnessLevel) {
+        const observer = this.observers.get(observerId);
+        if (observer) {
+            observer.consciousnessLevel = consciousnessLevel;
+            observer.lastObservation = Date.now();
+        }
+    }
+    /**
+     * Notify all observers of an event
+     */
+    notifyObservers() {
+        this.observers.forEach((observer) => {
+            // Simulate observer notification
+            observer.lastObservation = Date.now();
+        });
+    }
+}
+exports.ObserverAwareField = ObserverAwareField;