zeropoint-node 1.0.0 → 1.0.1

package/dist/core/ZeroPointSystem.js

@@ -0,0 +1,343 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroPointSystem = void 0;
+const DimensionRegistry_1 = require("./DimensionRegistry");
+const KnowledgeRegistry_1 = require("./KnowledgeRegistry");
+const applyLaws_1 = require("./applyLaws");
+/**
+ * Unified ZeroPoint System
+ * Provides DRY access to all knowledge across dimensions
+ */
+class ZeroPointSystem {
+    constructor() {
+        this.isInitialized = false;
+        this.dimensionRegistry = new DimensionRegistry_1.DimensionRegistry();
+        this.knowledgeRegistry = new KnowledgeRegistry_1.KnowledgeRegistry();
+    }
+    /**
+     * Initialize the system with all dimensions and knowledge units
+     */
+    async initialize() {
+        if (this.isInitialized)
+            return;
+        // Register all dimensions
+        await this.registerAllDimensions();
+        // Register all knowledge units
+        await this.registerAllKnowledge();
+        // Apply metaphysical laws to all knowledge units
+        await this.applyLawsToAll();
+        this.isInitialized = true;
+    }
+    /**
+     * Register all dimensions in the system
+     */
+    async registerAllDimensions() {
+        // 1D Dimensions
+        this.registerDimension({
+            name: 'point',
+            type: 'geometric',
+            complexity: 1,
+            isActive: true,
+            parent: null,
+            dependencies: [],
+            compatibleDimensions: ['line', 'plane', 'space'],
+            supportedOperations: ['create', 'transform', 'observe'],
+            description: 'Zero-dimensional point of infinite potential'
+        });
+        this.registerDimension({
+            name: 'line',
+            type: 'geometric',
+            complexity: 2,
+            isActive: true,
+            parent: 'point',
+            dependencies: ['point'],
+            compatibleDimensions: ['point', 'plane', 'space'],
+            supportedOperations: ['create', 'transform', 'observe', 'extend'],
+            description: 'One-dimensional line connecting points'
+        });
+        // 2D Dimensions
+        this.registerDimension({
+            name: 'plane',
+            type: 'geometric',
+            complexity: 3,
+            isActive: true,
+            parent: 'line',
+            dependencies: ['line'],
+            compatibleDimensions: ['point', 'line', 'space'],
+            supportedOperations: ['create', 'transform', 'observe', 'extend', 'rotate'],
+            description: 'Two-dimensional plane of manifestation'
+        });
+        // 3D Dimensions
+        this.registerDimension({
+            name: 'space',
+            type: 'geometric',
+            complexity: 4,
+            isActive: true,
+            parent: 'plane',
+            dependencies: ['plane'],
+            compatibleDimensions: ['point', 'line', 'plane', 'time'],
+            supportedOperations: ['create', 'transform', 'observe', 'extend', 'rotate', 'translate'],
+            description: 'Three-dimensional space of physical reality'
+        });
+        // 4D Dimensions
+        this.registerDimension({
+            name: 'time',
+            type: 'temporal',
+            complexity: 5,
+            isActive: true,
+            parent: 'space',
+            dependencies: ['space'],
+            compatibleDimensions: ['space', 'consciousness'],
+            supportedOperations: ['create', 'transform', 'observe', 'flow', 'reverse'],
+            description: 'Fourth dimension of temporal flow'
+        });
+        // Consciousness Dimensions
+        this.registerDimension({
+            name: 'consciousness',
+            type: 'metaphysical',
+            complexity: 6,
+            isActive: true,
+            parent: 'time',
+            dependencies: ['time'],
+            compatibleDimensions: ['time', 'void'],
+            supportedOperations: ['create', 'transform', 'observe', 'flow', 'evolve', 'unify'],
+            description: 'Dimension of conscious awareness and evolution'
+        });
+        // Void Dimensions
+        this.registerDimension({
+            name: 'void',
+            type: 'metaphysical',
+            complexity: 7,
+            isActive: true,
+            parent: 'consciousness',
+            dependencies: ['consciousness'],
+            compatibleDimensions: ['consciousness', 'unity'],
+            supportedOperations: ['create', 'transform', 'observe', 'unify', 'resolve'],
+            description: 'Infinite potential and source of all creation'
+        });
+        // Unity Dimensions
+        this.registerDimension({
+            name: 'unity',
+            type: 'metaphysical',
+            complexity: 8,
+            isActive: true,
+            parent: 'void',
+            dependencies: ['void'],
+            compatibleDimensions: ['void'],
+            supportedOperations: ['create', 'transform', 'observe', 'unify', 'resolve', 'transcend'],
+            description: 'Ultimate unity where all dimensions converge'
+        });
+    }
+    /**
+     * Register all knowledge units in the system
+     */
+    async registerAllKnowledge() {
+        // Import and register all existing knowledge units
+        const { ConsciousnessField } = await Promise.resolve().then(() => __importStar(require('../consciousness/ConsciousnessField')));
+        const { VortexMath } = await Promise.resolve().then(() => __importStar(require('../math/VortexMath')));
+        const { SacredGeometryRegistry } = await Promise.resolve().then(() => __importStar(require('../patterns/SacredGeometryRegistry')));
+        const { MetaphysicalLawRegistry } = await Promise.resolve().then(() => __importStar(require('../laws/MetaphysicalLawRegistry')));
+        // Register consciousness fields
+        this.registerKnowledgeUnit(new ConsciousnessField(), 'consciousness');
+        // Register mathematical systems
+        this.registerKnowledgeUnit(new VortexMath(), 'space');
+        // Register sacred geometry patterns
+        const sacredGeometry = new SacredGeometryRegistry();
+        for (const pattern of sacredGeometry.getAllPatterns()) {
+            this.registerKnowledgeUnit(pattern, 'plane');
+        }
+        // Register metaphysical laws
+        const laws = MetaphysicalLawRegistry.getAllLaws();
+        for (const law of laws) {
+            this.registerKnowledgeUnit(law, 'unity');
+        }
+        // Add void dimension knowledge units
+        const voidField = {
+            name: 'VoidField',
+            type: 'Field',
+            dimension: 'void',
+            complexity: 5,
+            isActive: true,
+            supportedOperations: ['create', 'transform', 'observe', 'unify'],
+            tags: ['void', 'field', 'metaphysical']
+        };
+        this.registerKnowledgeUnit(voidField, 'void');
+        // Add line dimension knowledge units
+        const linePattern = {
+            name: 'LinePattern',
+            type: 'Pattern',
+            dimension: 'line',
+            complexity: 1,
+            isActive: true,
+            supportedOperations: ['create', 'transform', 'observe'],
+            tags: ['line', 'pattern', 'geometric']
+        };
+        this.registerKnowledgeUnit(linePattern, 'line');
+    }
+    /**
+     * Apply metaphysical laws to all knowledge units
+     */
+    async applyLawsToAll() {
+        const allUnits = this.knowledgeRegistry.getAll();
+        // Only include objects that have an apply function and description
+        const laws = this.knowledgeRegistry.getByType('MetaphysicalLaw').filter((law) => typeof law.apply === 'function' && 'description' in law);
+        for (const unit of allUnits) {
+            for (const law of laws) {
+                (0, applyLaws_1.applyLaws)(unit, [law]);
+            }
+        }
+    }
+    /**
+     * Register a dimension
+     */
+    registerDimension(dimension) {
+        this.dimensionRegistry.register(dimension);
+    }
+    /**
+     * Register a knowledge unit
+     */
+    registerKnowledgeUnit(unit, dimension) {
+        this.knowledgeRegistry.register(unit, dimension);
+    }
+    /**
+     * Get knowledge units by dimension
+     */
+    getKnowledgeByDimension(dimension) {
+        return this.knowledgeRegistry.getByDimension(dimension);
+    }
+    /**
+     * Get knowledge units by type
+     */
+    getKnowledgeByType(type) {
+        return this.knowledgeRegistry.getByType(type);
+    }
+    /**
+     * Get knowledge units by criteria
+     */
+    getKnowledgeByCriteria(criteria) {
+        return this.knowledgeRegistry.getByCriteria(criteria);
+    }
+    /**
+     * Get compatible knowledge units
+     */
+    getCompatibleKnowledge(unitName) {
+        return this.knowledgeRegistry.getCompatibleUnits(unitName);
+    }
+    /**
+     * Get dimensions by type
+     */
+    getDimensionsByType(type) {
+        return this.dimensionRegistry.getByType(type);
+    }
+    /**
+     * Get active dimensions
+     */
+    getActiveDimensions() {
+        return this.dimensionRegistry.getActiveDimensions();
+    }
+    /**
+     * Get knowledge units that support an operation
+     */
+    getKnowledgeByOperation(operation) {
+        return this.knowledgeRegistry.getBySupportedOperation(operation);
+    }
+    /**
+     * Get dimensions that support an operation
+     */
+    getDimensionsByOperation(operation) {
+        return this.dimensionRegistry.getBySupportedOperation(operation);
+    }
+    /**
+     * Activate a dimension and its knowledge
+     */
+    activateDimension(name) {
+        this.dimensionRegistry.activateDimension(name);
+        // Activate all knowledge units in this dimension
+        const knowledgeUnits = this.getKnowledgeByDimension(name);
+        for (const unit of knowledgeUnits) {
+            this.knowledgeRegistry.activateUnit(this.getUnitName(unit));
+        }
+    }
+    /**
+     * Deactivate a dimension and its knowledge
+     */
+    deactivateDimension(name) {
+        this.dimensionRegistry.deactivateDimension(name);
+        // Deactivate all knowledge units in this dimension
+        const knowledgeUnits = this.getKnowledgeByDimension(name);
+        for (const unit of knowledgeUnits) {
+            this.knowledgeRegistry.deactivateUnit(this.getUnitName(unit));
+        }
+    }
+    /**
+     * Get a comprehensive summary of the system
+     */
+    getSystemSummary() {
+        return {
+            dimensions: this.dimensionRegistry.getSummary(),
+            knowledge: this.knowledgeRegistry.getSummary()
+        };
+    }
+    /**
+     * Get knowledge units ordered by complexity
+     */
+    getKnowledgeByComplexity() {
+        return this.knowledgeRegistry.getOrderedByComplexity();
+    }
+    /**
+     * Get dimensions ordered by complexity
+     */
+    getDimensionsByComplexity() {
+        return this.dimensionRegistry.getOrderedByComplexity();
+    }
+    /**
+     * Helper method to get unit name
+     */
+    getUnitName(unit) {
+        if ('name' in unit && unit.name)
+            return unit.name;
+        if ('id' in unit && unit.id)
+            return unit.id;
+        return 'unknown';
+    }
+    /**
+     * Check if system is initialized
+     */
+    isSystemInitialized() {
+        return this.isInitialized;
+    }
+}
+exports.ZeroPointSystem = ZeroPointSystem;

package/dist/core/applyLaws.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyLaws = applyLaws;
+function applyLaws(subject, laws, context) {
+    let result = subject;
+    for (const law of laws) {
+        if (typeof law.apply === 'function') {
+            result = law.apply(result, context);
+        }
+    }
+    return result;
+}

package/dist/core/applyOperations.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply = apply;
+exports.applyAll = applyAll;
+const ComplianceSystem_1 = require("./ComplianceSystem");
+function apply(subject, op, context) {
+    // Validate operation for full compliance before execution
+    if (!(0, ComplianceSystem_1.validateFullCompliance)(op, context)) {
+        throw new Error(`Operation ${op.name} failed comprehensive compliance check`);
+    }
+    return op.execute(subject, context);
+}
+function applyAll(subject, ops, context) {
+    // Validate all operations for full compliance before execution
+    for (const op of ops) {
+        if (!(0, ComplianceSystem_1.validateFullCompliance)(op, context)) {
+            throw new Error(`Operation ${op.name} failed comprehensive compliance check`);
+        }
+    }
+    return ops.reduce((acc, op) => apply(acc, op, context), subject);
+}

package/dist/devices/DeviceRegistry.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceRegistry = void 0;
+const MetaphysicalLawRegistry_1 = require("../laws/MetaphysicalLawRegistry");
+const ResonanceDevices_1 = require("./ResonanceDevices");
+/**
+ * Registry for resonance devices
+ * Manages devices and their interactions with metaphysical laws
+ */
+class DeviceRegistry {
+    constructor() {
+        this.devices = new Map();
+        this.lawRegistry = MetaphysicalLawRegistry_1.MetaphysicalLawRegistry.getInstance();
+        this.initializeDefaultDevices();
+    }
+    static getInstance() {
+        if (!DeviceRegistry.instance) {
+            DeviceRegistry.instance = new DeviceRegistry();
+        }
+        return DeviceRegistry.instance;
+    }
+    /**
+     * Initialize default devices
+     */
+    initializeDefaultDevices() {
+        this.registerDevice(new ResonanceDevices_1.HarmonicAmplifier());
+        this.registerDevice(new ResonanceDevices_1.ConsciousnessResonator());
+        this.registerDevice(new ResonanceDevices_1.UnityHarmonizer());
+        this.registerDevice(new ResonanceDevices_1.PolarityBalancer());
+    }
+    /**
+     * Register a new device
+     */
+    registerDevice(device) {
+        // Apply all metaphysical laws to the device
+        const laws = this.lawRegistry.getAllLaws();
+        laws.forEach(law => {
+            law.apply(device);
+        });
+        this.devices.set(device.name, device);
+    }
+    /**
+     * Get a device by name
+     */
+    getDevice(name) {
+        return this.devices.get(name);
+    }
+    /**
+     * Get all devices
+     */
+    getAllDevices() {
+        return Array.from(this.devices.values());
+    }
+    /**
+     * Get devices by type
+     */
+    getDevicesByType(type) {
+        return Array.from(this.devices.values()).filter(device => device.type === type);
+    }
+    /**
+     * Tune all devices to a specific frequency
+     */
+    tuneAllDevices(frequency) {
+        this.devices.forEach(device => {
+            device.tuneTo(frequency);
+        });
+    }
+    /**
+     * Create a device network for coordinated amplification
+     */
+    createDeviceNetwork() {
+        const devices = Array.from(this.devices.values());
+        const network = {
+            devices: devices.map(device => ({
+                name: device.name,
+                type: device.type,
+                resonanceFrequency: device.resonanceFrequency,
+                amplificationFactor: device.amplificationFactor
+            })),
+            coordinatedAmplification: this.calculateCoordinatedAmplification(devices)
+        };
+        return network;
+    }
+    /**
+     * Calculate coordinated amplification from multiple devices
+     */
+    calculateCoordinatedAmplification(devices) {
+        if (devices.length === 0)
+            return 0;
+        const totalAmplification = devices.reduce((sum, device) => {
+            return sum + device.amplificationFactor;
+        }, 0);
+        const harmonicFactor = devices.length > 1 ? Math.log2(devices.length) : 1;
+        return totalAmplification * harmonicFactor;
+    }
+    /**
+     * Amplify a target using all devices
+     */
+    amplifyWithAllDevices(target) {
+        const devices = Array.from(this.devices.values());
+        const amplifications = devices.map(device => ({
+            device: device.name,
+            amplification: device.amplify(target),
+            resonance: device.calculateResonance(target.vibrationalFrequency || 1)
+        }));
+        const totalAmplification = amplifications.reduce((sum, amp) => sum + amp.amplification, 0);
+        return {
+            target,
+            amplifications,
+            totalAmplification,
+            averageResonance: amplifications.reduce((sum, amp) => sum + amp.resonance, 0) / amplifications.length
+        };
+    }
+    /**
+     * Create a resonance field using multiple devices
+     */
+    createMultiDeviceField(radius) {
+        const devices = Array.from(this.devices.values());
+        const fields = devices.map(device => device.createResonanceField(radius));
+        return {
+            combinedField: {
+                radius,
+                devices: devices.length,
+                totalAmplification: this.calculateCoordinatedAmplification(devices),
+                fieldStrength: fields.reduce((sum, field) => sum + field.fieldStrength, 0),
+                harmonics: fields.flatMap(field => field.harmonics)
+            },
+            individualFields: fields
+        };
+    }
+    /**
+     * Get device signatures for analysis
+     */
+    getDeviceSignatures() {
+        return Array.from(this.devices.values()).map(device => ({
+            name: device.name,
+            type: device.type,
+            signature: device.getResonanceSignature()
+        }));
+    }
+    /**
+     * Find devices that resonate with a target
+     */
+    getResonatingDevices(target, threshold = 0.5) {
+        return Array.from(this.devices.values()).filter(device => {
+            const resonance = device.calculateResonance(target.vibrationalFrequency || 1);
+            return resonance >= threshold;
+        });
+    }
+}
+exports.DeviceRegistry = DeviceRegistry;

package/dist/devices/ResonanceDevice.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResonanceDevice = void 0;
+const MetaphysicalArtifact_1 = require("../artifacts/MetaphysicalArtifact");
+/**
+ * Base class for resonance devices
+ * Devices that amplify, harmonize, or transform metaphysical energies
+ */
+class ResonanceDevice extends MetaphysicalArtifact_1.MetaphysicalArtifact {
+    constructor(name, description, type) {
+        super(name, description, type);
+        this.resonanceFrequency = 0;
+        this.amplificationFactor = 1;
+        this.harmonicMultipliers = [1, 2, 3, 5, 8]; // Golden ratio harmonics
+        this.targetFrequencies = [];
+    }
+    /**
+     * Tune the device to a specific frequency
+     */
+    tuneTo(frequency) {
+        this.resonanceFrequency = frequency;
+        this.targetFrequencies = this.harmonicMultipliers.map(mult => frequency * mult);
+        this.amplificationFactor = this.calculateAmplificationFactor();
+    }
+    /**
+     * Calculate amplification factor based on resonance alignment
+     */
+    calculateAmplificationFactor() {
+        const baseAmplification = 1.5;
+        const lawCompliance = Array.from(this.lawCompliance.values()).filter(Boolean).length;
+        return baseAmplification * (1 + lawCompliance * 0.2);
+    }
+    /**
+     * Amplify a target's vibrational frequency
+     */
+    amplify(target) {
+        const targetFrequency = target.vibrationalFrequency || 1;
+        const resonance = this.calculateResonance(targetFrequency);
+        return targetFrequency * this.amplificationFactor * resonance;
+    }
+    /**
+     * Calculate resonance between device and target frequency
+     */
+    calculateResonance(targetFrequency) {
+        const frequencyDiff = Math.abs(this.resonanceFrequency - targetFrequency);
+        const maxDiff = Math.max(this.resonanceFrequency, targetFrequency);
+        return Math.max(0, 1 - (frequencyDiff / maxDiff));
+    }
+    /**
+     * Harmonize multiple frequencies
+     */
+    harmonize(frequencies) {
+        if (frequencies.length === 0)
+            return 0;
+        const harmonicMean = frequencies.reduce((sum, freq) => sum + (1 / freq), 0);
+        const harmonizedFrequency = frequencies.length / harmonicMean;
+        return this.amplify({ vibrationalFrequency: harmonizedFrequency });
+    }
+    /**
+     * Create a resonance field around the device
+     */
+    createResonanceField(radius) {
+        return {
+            center: this,
+            radius,
+            frequency: this.resonanceFrequency,
+            amplification: this.amplificationFactor,
+            harmonics: this.targetFrequencies,
+            fieldStrength: this.calculateFieldStrength(radius)
+        };
+    }
+    /**
+     * Calculate field strength at a given radius
+     */
+    calculateFieldStrength(radius) {
+        const baseStrength = this.powerLevel * this.consciousnessResonance;
+        return baseStrength / (1 + radius * 0.1); // Inverse square law approximation
+    }
+    /**
+     * Get device resonance signature
+     */
+    getResonanceSignature() {
+        return {
+            ...this.getMetaphysicalSignature(),
+            resonanceFrequency: this.resonanceFrequency,
+            amplificationFactor: this.amplificationFactor,
+            harmonicMultipliers: this.harmonicMultipliers,
+            targetFrequencies: this.targetFrequencies
+        };
+    }
+}
+exports.ResonanceDevice = ResonanceDevice;